Move the loader onto the 68000, and find 5,920 bytes nobody counted

src/player/load.i expands both codebooks to word-per-pixel form and packs the
palette to GGGGGRRRRRBBBBBI out of the RAW container header, byte-exact against
tools/bench/dlxload.py on both CPU cores.  The palette half is gated on words
read back out of the palette registers at $E82000, so "the words reached the
hardware" is part of what passes.  ROADMAP P1 is done; P2's encoder half (a
reserved black entry, 23.4) is not, and is a re-encode rather than an edit.

A scene change costs 18.96 ms of 68000 time, 22.8% of one 12 fps frame; boot
costs 24.70 ms.  The scratch tables describe the CRTC, not the scene, so
pal_tables is a separate entry point built once at boot -- 5.29 ms off every
scene change.

The one that moves something: the scene header is 5,920 B that no rate table in
this tree included, because it belongs to no frame record.  In FINDINGS 51.3's
currency it is divided by the surplus pipe - wire, so it is hypersensitive:
138 ms of extra refill climb at 488 KB/s and 1.099 s at 451.4 KB/s, for the
same bytes.  tools/analysis/22_scene_load.py prices it across explicit rates.

Recorded as open: the two CPU cores agree to <3% on every stage but the table
build, where they differ by 16.4%.  px68k's C68K charges a flat 50 clocks for
MULU/MULS (c68kmacro.h:1869) where the 68000 charges 38+2n, which explains
4,608 of the 8,703 clock gap.  4,095 clocks are unexplained.  Nothing else in
src/player/ multiplies, so no figure in FINDINGS 24-52 is affected.

decode.s and stream.s are untouched; decode.bin is still 1,296 B at the same
MD5.  check.sh gains a stage that gates byte-exactness on both cores and
deliberately does not gate the cycle counts -- MAME's clock is 1/55.46 s and a
wall timing would make the green light host-sensitive.

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

src/player/loadgate.s

@@ -0,0 +1,38 @@
+; Front-end for the load-time transforms (ROADMAP P1+P2), for the rig.
+;
+; It is to load.i what decode.s is to frame.i: a timing and control wrapper that
+; does nothing the shipping player would not do, so that the bytes being
+; measured are the bytes that will ship.  The player's own boot path will call
+; do_load once with the mode bits set to 3; this repeats it LITER times so a
+; host clock with 1/55.46 s granularity can time a job that takes milliseconds,
+; and splits it by LMODE so the codebook expansion and the palette pack can be
+; priced apart.  A player calls do_load with mode 7 once at boot -- the three
+; scratch tables describe the machine, not the scene -- and with mode 3 at every
+; scene change after that.
+;
+; Repeating is honest here in a way it would not be for a frame: nothing in
+; do_load is temporally recursive.  Pass n writes exactly what pass n-1 wrote,
+; over the top of it, out of the same source bytes.
+
+        include "src/player/geom.i"
+
+        org     $10000
+start:
+        move.l  LMODE.l,d1
+        move.l  LITER.l,d3
+        move.l  #1,LFLAG.l              ; timer starts here
+loop:
+        movem.l d1/d3,-(sp)
+        movea.l LHDR.l,a0
+        bsr     do_load
+        movem.l (sp)+,d1/d3
+        tst.l   d0
+        bne.s   bad
+        subq.l  #1,d3
+        bne.s   loop
+        move.l  #$FF,LFLAG.l            ; timer stops here
+hold:   bra.s   hold
+bad:    move.l  #$EE,LFLAG.l
+        bra.s   hold
+
+        include "src/player/load.i"