v0.6.2 — an Extra starts where you put it, a train card is never discarded

Three more from the v0.4.9e gameplay-testing round, filed as Gitea issues, plus two bugs found
underneath them. Gitea#2 is diagnosed but NOT fixed: it needs a ruling, and the reasoning is in
TODO.md under Play Balance.

GITEA#4 — AN EXTRA STARTS WHERE THE PLAYER PUTS IT. Only one Division Point was ever offered,
chosen by number parity. The number no longer decides an Extra's direction — the start does, which
supersedes the recorded ruling that "the number decides, like everything else on the timetable".
The two cannot both hold: an odd, westbound Extra placed at the WEST end would leave the Division
on its first move having crossed nothing, and be paid for the run. Either end now runs the train
away from itself; at an Interchange or a Control Point the player picks the direction. The
Interchange start is a YARD, off the running line, which is what makes the Superintendent clause
work: placing it can never force a collision, a guaranteed one holds it there for another Stage,
and a potential one is the Superintendent's to rule on — exactly evaluateClearance's `blocked` and
`ask`, so nothing new decides collisions. Where an Extra may start is now a house rule
(divisionPointsOnly / ownOffice / anyOffice, defaulting to what the engine already did). The
legacy `atSeat` intent field still replays as it always meant.

FOUND UNDERNEATH IT: an Extra started away from a Division Point ran empty. isBeingMadeUp tested
position alone, so the Control Point start has been shipping since it was added with a train that
could never be given a consist. Found by playing it, not by the tests, which had only asserted
where the tray landed.

FOUND UNDERNEATH IT: collide left the wrecks on the card. Destroyed trains kept their Transit
entries, and evaluateClearance counts every transit as an occupant, so one rear-end collision
permanently poisoned that Mainline card for every later train.

THE MAINLINE CARDS WERE ROLLED, NOT DEALT — drawn from the nine types with replacement, so a
Division could hold two Interchanges and Plains carried the weight of a card printed once. "An
Extra may start at the Interchange if one is on the board" only reads as a rule if the board holds
at most one. Now dealt from the printed deck without replacement, verified over 1600 deals. This
re-deals every seed: the published replays were re-recorded, and the saved games in docs/ are
retired too — two of those were already dead before this release and nobody had noticed.

GITEA#6 — A TRAIN CARD IS NEVER DISCARDED, Timetabled and Extra alike. The forced play needed no
mechanism: nothing discardable plus a hand over the limit leaves exactly one legal way to end the
turn, and playing a train is unconditionally legal, so the corner cannot trap anyone. The bot
needed no rule either. 400/400 games finished, revenue unmoved, trains scheduled 1.2 -> 1.3. The
player is told on the card and on the button.

GITEA#7 — COACH COUNTS. 1/2 Crack Limited 3 -> 2, 5/6 The Sparrow 2 -> 3. A change to the cards,
so Trains3.pdf and the transcription keep the original numbers with a footnote while content.ts
and the Home Deck reference carry what the game plays.

CONTENT.TS COMMENT PASS — no data changed, only comments. Four were factually wrong, including an
office table naming counts doubled long ago and a pointer to a DEALT_DECK_SIZE that has never
existed. Every Enhancement row cited its implementation by line number and every citation had
rotted; they name functions now. Card counts came out of the comments, since they move with play
balance; source-sheet figures and dated measurements stayed.

TODO.md gains an item for a card reference generated from content.ts, in six sections, so the
documentation cannot disagree with the game.

715 tests pass, tsc clean, site builds.

src/engine/advance.ts

@@ -456,6 +456,9 @@ function enterMainline(
   );
   node.transits.push({ tray: id, stagesRemaining: stages, stagesTotal: stages, direction: tray.direction });
   tray.position = { at: 'mainline', index };
+  // It is running now, so it is no longer being assembled (state.ts). A train at a Division Point
+  // needs no equivalent: leaving one changes its position, which is what that case reads.
+  delete tray.beingMadeUp;
 
   /**
    * OUT OF THE DISTRICT, AND THE SPUR PORT GOES WITH IT.
@@ -653,6 +656,43 @@ function moveTrain(s: GameState, id: TrayId, tray: CrewTray, events: GameEvent[]
     const node = s.division.nodes[index];
     if (!node || node.kind !== 'mainline') return 'held';
 
+    /**
+     * §7/§8.1 — AN EXTRA HIGHBALLING OUT OF THE INTERCHANGE'S YARD.
+     *
+     * Standing in `holding` rather than crossing in `transits` (state.ts), which is the position an
+     * Extra started at an Interchange begins in. It leaves exactly the way a train at a Division
+     * Point does — clearance first, then onto the running line — except that the card it enters is
+     * the one it is already standing beside rather than the next one along.
+     *
+     * That reuse is the whole point of modelling the yard separately: Jesse's rule is "a guaranteed
+     * collision holds it at the Interchange for another Stage and it tries again; a potential one is
+     * the Superintendent's to hold", and those are precisely `evaluateClearance`'s `blocked` and
+     * `ask`. Nothing new decides collisions here.
+     */
+    if (node.holding?.includes(id)) {
+      const clearance = evaluateClearance(s, id, tray, index, events);
+      if (clearance === 'blocked') {
+        events.push({
+          type: 'trainHeld',
+          trainNumber: tray.trainNumber ?? 0,
+          reason: 'held in the Interchange — the Subdivision ahead is occupied',
+        });
+        return 'held';
+      }
+      if (clearance === 'ask') return 'needsClearance';
+
+      node.holding = node.holding.filter((t) => t !== id);
+      enterMainline(s, node, id, tray, index);
+      events.push({
+        type: 'trainHighballed',
+        trainNumber: tray.trainNumber ?? 0,
+        from: 'the Interchange',
+        to: 'the Mainline',
+        why: 'it was made up in the yard and the Subdivision was clear, so its run begins',
+      });
+      return 'moved';
+    }
+
     const transit = node.transits.find((t) => t.tray === id);
     if (!transit) return 'held';
 
@@ -967,6 +1007,25 @@ function collide(
     }
     s.trays.delete(id);
     s.freeTrays.push(id);
+    /**
+     * TAKE THE WRECK OFF THE CARD.
+     *
+     * Nothing did. `s.trays.delete` removed the train and left its `Transit` sitting on the Mainline
+     * card it died on, and `evaluateClearance` counts every transit as an occupant — so a rear-end
+     * collision (the caller at "ran into the train ahead") permanently poisoned that card: every
+     * later train was either held against a ghost or put to the Superintendent about one. The only
+     * other place a transit is removed is a train rolling off the far end, which a destroyed train
+     * never does.
+     *
+     * Found while adding the Interchange start, which clears onto the running line through that
+     * same occupant list.
+     */
+    for (const n of s.division.nodes) {
+      if (n.kind !== 'mainline') continue;
+      n.transits = n.transits.filter((t) => t.tray !== id);
+      if (n.holding) n.holding = n.holding.filter((t) => t !== id);
+      if (n.redFlagged) n.redFlagged = n.redFlagged.filter((t) => t !== id);
+    }
   }
 
   if (lost.length > 0) {