Price cycles in the mode decision: 37 misses become 1, for 0.26 dB

The decoder has been CPU-bound since FINDINGS 28 while the mode decision
minimised D + lam*R -- distortion against BYTES. decide() now minimises
D + lam*bytes + mu*cycles, and ratectl bisects mu per frame against the
833,333-cycle budget with the lam bisection nested inside it. On the worst
sustained window:

  sasi  27.22 -> 26.95 dB, 109.5 -> 109.4 KB/s, 37/120 misses -> 1
  scsi  29.90 -> 29.27 dB, 280.0 -> 278.6 KB/s, 51/120 misses -> 1

Bitrate does not move: the byte controller still binds, and mu changes WHICH
modes are bought. V4 is what it stops buying -- 25.2 -> 20.3% of blocks at sasi
and 15.0 -> 5.3% at scsi, where RAW takes it. That is 28.8's inversion in
practice: RAW is dearer in bytes and cheaper in cycles, so only the byte-rich
profile can buy its way out of V4.

Three things worth knowing beyond the headline:

  - The one frame that still misses, at both profiles, is FRAME 0 -- no previous
    reconstruction, so 100% changed by definition, which is also what a scene
    cut is. It comes out at the all-V1 floor of 110.6% and is emitted late on
    purpose. Freezing a cut to make a deadline is the worse failure.
  - 28.7's "11 frames are impossible" was too pessimistic. That floor held the
    SKIP set fixed and asked how cheaply the drawn blocks could be drawn; the
    real decision can also MOVE a block to SKIP, which above ~90% non-SKIP is
    the only lever left.
  - SKIP's price depends on its neighbours (13.25 cycles clustered, 45 mixed),
    which a per-block lagrangian cannot see. The way out is that the two uses
    need not share a cost function: a ranking constant inside decide(), the
    exact clustered rule for the frame-level bisection. vq_hybrid.cycles() is
    now the one definition of that rule and 11_cpu_budget.py imports it.

Gated: 09_ratectl_drift.py runs both controllers, both 0/120 drifting frames.
The cost-aware container decodes pixel-exact on the 68000 (120 frames). ON by
default in encode.py; --no-cpu-fit restores session 7. check.sh ALL GREEN.

Still a model, not a measurement, for THIS container: FINDINGS 31's cycle
figures come from vq_hybrid.cycles (within 1 point of the 68000 on four frames
of the session-7 container). Timing this one on the machine is step 1 of the
next session -- it was started and killed for time, and it is slow.

FINDINGS 31. tools/analysis/13_cpu_ratectl.py.

Claude-Session: https://claude.ai/code/session_01194oWYW8DQXK1SZ2DnChW6

tools/analysis/11_cpu_budget.py

@@ -22,6 +22,7 @@ import sys, os, argparse
 sys.path.insert(0, "tools/encoder")
 import numpy as np
 from dlx import DLX
+import vq_hybrid as H
 
 # Machine clocks, confirmed from MAME 0.277 src/mame/sharp/x68k.cpp:1133/1194/
 # 1200 -- not recalled. x68000 and x68ksupr are BOTH 40_MHz_XTAL/4 = 10 MHz;
@@ -30,10 +31,13 @@ from dlx import DLX
 CLOCKS = {"stock": 10.0, "super": 10.0, "xvi": 33.33 / 2, "x68030": 25.0}
 FPS = 12
 
-# cycles per block, measured on the emulated 68000 (synthetic single-mode frames)
-C_V1, C_V4, C_RAW = 299.9, 448.2, 400.4
-C_SKIP_FAST = 53.0 / 4                    # all-SKIP header byte: one tst.b for 4
-C_SKIP_MIXED = 45.0                       # a SKIP block inside a mixed byte
+# Cycles per block, measured on the emulated 68000 (synthetic single-mode
+# frames). Defined in tools/encoder/vq_hybrid.py, which is where the mode
+# decision needs them too -- one copy, not two, so a re-measurement cannot
+# leave the encoder and the scorer disagreeing.
+C_V1, C_V4, C_RAW = H.C_V1, H.C_V4, H.C_RAW
+C_SKIP_FAST, C_SKIP_MIXED = H.C_SKIP_CLUSTERED, H.C_SKIP_MIXED
+cycles = H.cycles
 
 ap = argparse.ArgumentParser()
 ap.add_argument("container", nargs="?",
@@ -50,17 +54,6 @@ if not os.path.exists(a.container):
 
 d = DLX(a.container)
 
-def cycles(mode):
-    g = mode.reshape(-1, 4)               # one header byte = four blocks
-    allskip = (g == 0).all(1)
-    c = allskip.sum() * 4 * C_SKIP_FAST
-    m = g[~allskip]
-    c += (m == 0).sum() * C_SKIP_MIXED
-    c += (m == 1).sum() * C_V1
-    c += (m == 2).sum() * C_V4
-    c += (m == 3).sum() * C_RAW
-    return c
-
 modes = [d.modes(f) for f in range(d.nframes)]
 cyc = np.array([cycles(m) for m in modes])
 pct = 100 * cyc / FRAME