I finally wrote a script that mutes events on lower tracks if they are covered by events on tracks above. It is similar to what wwaag wrote, but is done with old-fashioned jscript. Since I am still using ancient versions of Vegas, I don't know if jscript is still supported in the more modern versions.

The purpose of the script is to significantly reduce render times in certain multi-track Vegas projects.

The unnecessarily long renders happen if you have a non-trasnparent fX on an upper track (e.g., Levels, or Color Corrector) and then have complex operations being performed on lower tracks, but which don't show through. For a test case I put three copies of the slowest fX (min/max) on events on three lower tracks. I first soloed the top track and my test render took 9 seconds. I then un-soloed the track, and verified that the video in the Vegas preview display didn't change (i.e., the lower track video wasn't going to be used). I then rendered my few seconds, and the render estimate went from nine seconds to over ten minutes.

I'm providing this script as is, with the understanding that it may not work with modern versions of Vegas, if they've taken away jscript support, and also with the understanding that you have to make sure that you don't have any way that the "covered" events on the lower track could show through (see the Notes section in the script for examples). The script does handle event fades and opacity level, but is oblivious to any track operations, and also does not handle any changes made with a compositing envelope. Bottom line: it can be fooled, but for many projects, it can make a massive reduction in render times.

/**
* Mute video events on lower tracks if they are completely covered by any event on tracks above.
*
* Written By: John Meyer
* Written: October 11, 2021
*
* The script mutes events on all secondary tracks which are completely covered by events on tracks above.
* The reason for this script is that, under many circumstances, Vegas will needlessly composite video on lower tracks
* even if that video is never used. This can cause render times to balloon, often by integer multiples (2x, 3x, etc.)
*
* For the problem to happen, the upper events must have some non-transparent fX applied or must have a zoom in pan/crop, neither of which should allow
* lower events to show through, but both of which cause Vegas to needlessly render lower tracks. Mixing videos with different PARs can also cause problems.
*
* Discussion about problem here:
* https://www.vegascreativesoftware.info/us/forum/possible-explanation-for-some-slow-renders-bug--99410
*
* NOTE:
* This script will create problems if fX on upper events create transparency that let lower events show through, e.g., the Cookie Cutter fX.
* It should not be used when nested tracks are present.
* It will create problems if pan/crop causes video to shrink, or if rotation is used, or anything else that lets lower events show through.
* Any track-level panning will cause problems
* Any compositing envelope will cause problems
*
**/import System;
import System.IO;
import System.Windows.Forms;
import Sony.Vegas;  
/**
**************************************************************************
* Start of main program                                                  *
**************************************************************************
**/try {
    var evnt_last        : TrackEvent;
    var evnt             : TrackEvent;
    var scratch_evnt     : TrackEvent;
    var currenttrack     : Track;
    var eventEnum        : Enumerator;        
    var scratchtrackEnum : Enumerator;
    var ZeroFadelength   : Timecode = new Timecode("00:00:00:00");//  Add top scratch track
    var scratchtrack     : VideoTrack = new VideoTrack();
    Vegas.Project.Tracks.Add(scratchtrack);               // Add track.
    scratchtrack.Name = "Scratch Track ***Delete***";     // Add track header reminder, in case script gets interrupte and temp track remains//  Get list of tracks and enumerate the scratch track events
    var trackEnum = new Enumerator(Vegas.Project.Tracks);    
    var moretracks = FindNextVideoTrack();
    while (moretracks) {                   // Iterate through all video tracks, ignoring audio tracks
      currenttrack     = Track(trackEnum.item());   //    Copy all events on current track to scratch track
      eventEnum = new Enumerator(currenttrack.Events);
      while (!eventEnum.atEnd()) {
        evnt = TrackEvent(eventEnum.item());
        evnt.Copy(scratchtrack,evnt.Start);
        eventEnum.moveNext();
      } // End while (!eventEnum.atEnd()//    Merge overlapped events on scratch track into one event with no fades
      if (scratchtrack.Events.Count > 0) {
        MergeScratchTrackEvents();
      }
      else {
        throw ("No video events on top video track");  // I'm not sure this can happen, but in case it does ...
      }//    Split events on next track
      moretracks = FindNextVideoTrack();
      if (!moretracks)         //Get next video track, if there is one, otherwise exit while loop, clean up, and go home.
           break;  
      currenttrack = Track(trackEnum.item());  
      SplitEvents ();//    Mute all events on current track that will never bee seen in final video
      MuteCoveredEvents ();  } // End while (moretracks)
      Vegas.UpdateUI();    Vegas.Project.Tracks.Remove(scratchtrack);} catch (e) {
  MessageBox.Show(e);
}// End of main program
// ***********************************************************************
// Beginning of functions
// ***********************************************************************// Get next video track, skipping audio tracks. Return null if no more video tracks
function FindNextVideoTrack() : boolean{
  trackEnum.moveNext();
  while (!trackEnum.atEnd()) {
    var track : Track = Track(trackEnum.item());
    if (track.IsVideo()) {
      return 1;
    }
  trackEnum.moveNext();
  }
  return 0;
}// Merge overlapped events on scratch track, preserving fade on last event in groupfunction MergeScratchTrackEvents () {
  eventEnum = new Enumerator(scratchtrack.Events);
  evnt_last = TrackEvent(eventEnum.item());  // Before iterating through events, fix fade on first event
  // Shorten first event if it has a fade-in, because fade will allow lower track to show through
  evnt_last.Start = evnt_last.Start + evnt_last.FadeIn.Length;
  evnt_last.Length =  evnt_last.Length - evnt_last.FadeIn.Length;
  evnt_last.FadeIn.Length = ZeroFadelength;  // Remove first event if it has opacity set to less than 100%
  if (evnt_last.FadeIn.Gain < 1 ) {
       scratchtrack.Events.Remove(evnt_last);
       eventEnum = new Enumerator(scratchtrack.Events); // Re-enumerate after event is removed
       evnt_last = TrackEvent(eventEnum.item());
  }  eventEnum.moveNext();  // Go though all events after first one
  while (!eventEnum.atEnd()) {
     evnt = TrackEvent(eventEnum.item());     // Fades that don't overlap with adjacent event will let video show through, so event must be shortened by fade amount
     // This "if" handles fade-in, the next "if" handles fade-out     if (evnt.FadeIn.Length > ZeroFadelength && evnt.Start >= evnt_last.End ) {
       evnt.Start         = evnt.Start + evnt.FadeIn.Length;
       evnt.Length        = evnt.Length - evnt.FadeIn.Length;
       evnt.FadeIn.Length = ZeroFadelength;
     }     if (evnt_last.FadeOut.Length > ZeroFadelength && evnt_last.End <= evnt.Start ) {
       evnt_last.Length         = evnt_last.Length - evnt_last.FadeOut.Length;
       evnt_last.FadeOut.Length = ZeroFadelength;
     }     // Remove events which have opacity less than 1
     // Original version attempted to also eliminate events with pan/crop setting.
     // The following line will also eliminate events containining any fX (replace "if" below)
     // if (evnt.FadeIn.Gain < 1 ||  videoEvent.Effects.Count>0 ) {     var videoEvent = VideoEvent(evnt);
     videoEvent.VideoMotion.ScaleToFill = true;     if (evnt.FadeIn.Gain < 1 ) {
        scratchtrack.Events.Remove(evnt);
        eventEnum = new Enumerator(scratchtrack.Events); // Re-enumerate after event is removed
        evnt_last = TrackEvent(eventEnum.item());
        eventEnum.moveNext();
        evnt = TrackEvent(eventEnum.item()); //Events are now re-enumerated, but function will start over at first event
     }     //Remove event completely contained within previous event
     if (evnt.Start >= (evnt_last.Start) && evnt.End <= (evnt_last.End)) {
        scratchtrack.Events.Remove(evnt);
        eventEnum = new Enumerator(scratchtrack.Events); // Re-enumerate after event is removed
        evnt_last = TrackEvent(eventEnum.item());
        eventEnum.moveNext();
        evnt = TrackEvent(eventEnum.item());
     }
     // Merge events which overlap or which are abutted
     if (evnt.Start <= (evnt_last.End) ) {
        evnt_last.Length = evnt.Start - evnt_last.Start + evnt.Length
        evnt_last.FadeOut.Length  = evnt.FadeOut.Length;
        scratchtrack.Events.Remove(evnt);
        eventEnum = new Enumerator(scratchtrack.Events); // Re-enumerate after event is removed
     }     evnt_last = TrackEvent(eventEnum.item());
     eventEnum.moveNext();  } // End while( !eventEnum.asEnd() )     // If last event on scratchtrack has fade out, make adjustment
     if (evnt_last.FadeOut.Length > ZeroFadelength  ) {
       evnt_last.Length = evnt_last.Length - evnt_last.FadeOut.Length;
       evnt_last.FadeOut.Length = ZeroFadelength;
     }
} // End Function MergeScratchTrackEvents()// This function splits events on the current track at the event boundaries on the scratch track.
function SplitEvents () {
  scratchtrackEnum = new Enumerator(scratchtrack.Events);
  while (!scratchtrackEnum.atEnd()) {
      scratch_evnt = TrackEvent(scratchtrackEnum.item());
      eventEnum = new Enumerator(currenttrack.Events); // restart enumeration of current track
      while (!eventEnum.atEnd()) {
        evnt = TrackEvent(eventEnum.item());
        // This will split events on current track at the begin/end event boundaries on the scratch track
        if (scratch_evnt.Start > evnt.Start && scratch_evnt.Start < evnt.End ) {
            evnt.Split(scratch_evnt.Start - evnt.Start) ;
        }
        if (scratch_evnt.End < evnt.End && scratch_evnt.End > evnt.Start ) {
            evnt.Split(scratch_evnt.End - evnt.Start) ;
        }
        eventEnum.moveNext();
      } // End while (!eventEnum.atEnd()      scratchtrackEnum.moveNext();  }  // End while (!scratchtrackEnum.atEnd()}  // End function SplitEvents// This function mutes the events on the current track which lie under the events on the scratch track
// No attempt is made to be intelligent about terminating loops early, etc.
function MuteCoveredEvents () {
  scratchtrackEnum = new Enumerator(scratchtrack.Events);
  while (!scratchtrackEnum.atEnd()) {
      scratch_evnt = TrackEvent(scratchtrackEnum.item());
      eventEnum    = new Enumerator(currenttrack.Events);   // restart enumeration of current track
      while (!eventEnum.atEnd()) {
        evnt = TrackEvent(eventEnum.item());
        if (scratch_evnt.Start <= evnt.Start && scratch_evnt.End >= evnt.End ) {
            evnt.Mute = true;
        }
        eventEnum.moveNext();
      } // End while (!eventEnum.atEnd()
      scratchtrackEnum.moveNext();
  }  // End ehile (!scratchtrackEnum.atEnd()
}