fix(AR-013): reap tracks on the evidence watermark, not the tracker's clock

The registry closed a track when the *tracker's* timestamp passed
`track_extinction_sec`. But votes arrive from the matcher, which is a separate
KPN node behind a channel, and much the slower of the pair. Backpressure —
working exactly as AR-004 intends — turns that channel's depth into lag, so
the tracker's clock can be far ahead of the last frame anybody has voted on.
Tracks were therefore closed before their evidence arrived: the votes landed
on ids that no longer existed, were counted as dropped, and the track was
emitted unowned or not at all.

The symptom is the part worth remembering: **a deeper channel produced fewer
identifications, from identical input.** On the SuperHero fixture, 5 actors /
16 windows at depth 32 against 3 actors / 5 windows at depth 10322; through
the replay harness, capacity 32 gave 5 actors and 10322 gave 0. A throughput
knob was silently changing the answer, which makes every sweep tuned against
it suspect.

The fix is not to bound the channel against `track_extinction_sec` — that
makes an algorithm constant police a throughput knob and leaves the result a
function of scheduling. It is to reap on an evidence watermark: the matcher
advances it as it folds each frame in, and a track is only finished once
everything up to its extinction point has actually been voted on. Same device
`SceneBoundaries::scored_through()` uses for the AR-010 join — a consumer past
that point is asking about frames nobody has looked at yet, and the honest
answer is to wait rather than guess.

Association keeps the tracker's clock, and separating the two is the other
half. They answer different questions: "may this detection link to that
track?" is asked now, about a box seen `track_extinction_sec` ago; "is that
track finished?" cannot be answered until every vote is in. Deferring
association to the evidence clock — which deferring the erase alone did — left
retired tracks associable for as long as the matcher lagged, so a new face
re-associated onto a long-dead track and two people merged into one window.

The watermark is monotonic and only ever *delays* a reap, so no window is
extended by it: AR-013's "a window ends at the last sighting, never after" is
a property of `emit_locked`, which takes `last_seen` and never `now`.

`dropped_votes` is exposed and reported — by main at shutdown and through the
replay bindings — because this failed silently for as long as it did precisely
because nothing counted it. It warns rather than aborts: a dropped frame means
the output describes footage nobody analysed and is always wrong, while a
dropped vote degrades a claim without falsifying it, and there is no
measurement yet of how often it happens on real content.

replay.py's channel capacity stops being the whole film. It was sized that way
to dodge a PyNode overflow drop that AR-004 has since replaced with parking,
and removing backpressure that way is what made the defect above so extreme.

Tag separators in kpn_bindings.cpp corrected to pipes between requirement
types, which the traceability gate was reporting as diagnostics; the matrix is
regenerated and reports 0 orphan tags.

149/149.

TRACES: AR-004, AR-012, AR-013, AR-025 | VR-011 | SR-002 | PR-002

scripts/optimizer/replay.py

@@ -171,14 +171,24 @@ def replay(dump_path: str, gallery: str, cfg: dict, build_dir: str,
         time.sleep(0.05)
         return eof
 
-    # Channel capacity must exceed the frame count so the fast source can't overflow
-    # a downstream FIFO before the serial reader drains it — PyNode DROPS on overflow,
-    # which would silently truncate the replay. Size to the whole film + slack.
-    # Every channel gets capacity ≥ the whole film so NOTHING can ever overflow-drop:
-    # the source can push all frames before any downstream node has drained, and a
-    # dropped frame silently corrupts the score. Memory is cheap (a few k pointers);
-    # correctness is not. Generous slack on top.
-    cap = len(frames) * 2 + 64
+    # TRACES: VR-011 | AR-004 | PR-002
+    # Purely a throughput and memory choice, and that is the point: the answer
+    # must not depend on it. It used to be `len(frames) * 2 + 64` -- the whole
+    # film -- to dodge a PyNode overflow drop that AR-004 has since replaced
+    # with parking.
+    #
+    # Removing backpressure that way was catastrophic and silent. The registry
+    # reaped on the TRACKER's clock while evidence arrived later from the
+    # matcher, so a deep channel closed tracks before their votes landed: on the
+    # SuperHero fixture, capacity 32 gave 5 actors and capacity 10322 gave 0,
+    # from identical input.
+    #
+    # The fix was NOT to bound this against track_extinction_sec. That would put
+    # an algorithm constant in charge of a throughput knob and leave presence a
+    # function of scheduling. The registry now reaps on the matcher's evidence
+    # watermark (TrackRegistry::advance_evidence), so a vote cannot be late by
+    # construction and this number is free again.
+    cap = 64
     sae_kpn.add_node_python(net, "replay", source, [], ["EmbeddedSceneFrame"], cap)
 
     # TRACES: VR-011, VR-002 | DP-001 | PR-002
@@ -224,10 +234,26 @@ def replay(dump_path: str, gallery: str, cfg: dict, build_dir: str,
                 f"({len(frames) - 1} frames); the sink never saw EOF")
         time.sleep(0.02)
 
+    diag = sae_kpn.pipeline_diagnostics(net)
     if stop:
         net.stop()
     sae_kpn.release_pipeline(net)
 
+    # TRACES: VR-011 | PR-002
+    # A dropped vote means the matcher lagged the tracker by more than
+    # track_extinction_sec of film, so evidence arrived for a track that had
+    # already been reaped. The result is not a slightly worse score -- it is a
+    # silently emptier one, and this is exactly how the whole-film capacity bug
+    # presented. Refuse the number rather than report it.
+    dropped = int(diag.get("dropped_votes", 0))
+    if dropped:
+        raise RuntimeError(
+            f"replay dropped {dropped} identity votes: the matcher fell more "
+            f"than track_extinction_sec behind the tracker, so presence is "
+            f"under-reported. Lower the channel capacity (currently {cap}) or "
+            f"raise track_extinction_sec.")
+
+
     with open(out_path) as f:
         result = json.load(f)