refactor(rundown): simplify gap and overlap accumulation

The gap/overlap detection is already a merge-intervals sweep: `latestEvent`
is the running max end and `getTimeFrom` is `start - maxEnd`. Making that
explicit collapses the branching around it.

- getTimeFrom: the three branches all returned the same subtraction
- totalDuration: the gap === 0 / gap > 0 / gap < 0 cases are all
  Math.max(duration + gap, 0), since duration is never negative

Same behaviour, no signature changes.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016XSraCPafWbAg35gAFrtgH

apps/server/src/api-data/rundown/rundown.parser.ts

@@ -309,18 +309,15 @@ function processEntry<T extends OntimeEntry>(
 
       entry.gap = getTimeFrom(entry, rundownMetadata.latestEvent);
 
-      if (entry.gap === 0) {
-        // event starts on previous finish, we add its duration
-        rundownMetadata.totalDuration += entry.duration;
-      } else if (entry.gap > 0) {
-        // event has a gap, we add the gap and the duration
-        rundownMetadata.totalDuration += entry.gap + entry.duration;
-      } else {
-        // there is an overlap, we remove the overlap from the duration
-        // ensuring that the sum is not negative (ie: fully overlapped events)
-        // NOTE: we add the gap since it is a negative number
-        rundownMetadata.totalDuration += Math.max(entry.duration + entry.gap, 0);
-      }
+      /**
+       * The rundown duration is the union of all event intervals, so each event
+       * only contributes the time it pushes past the latest event so far.
+       * - gap >= 0: the event contributes its gap plus its full duration
+       * - gap < 0: the event overlaps, only the part after the latest end counts
+       *   (clamped at 0 for events which are fully contained in a previous one)
+       * NOTE: gap is negative on overlap, so adding it removes the overlapping part
+       */
+      rundownMetadata.totalDuration += Math.max(entry.duration + entry.gap, 0);
 
       // remove eventual gaps from the accumulated delay
       // we only affect positive delays (time forwards)