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

tools/bench/check.sh

@@ -270,4 +270,28 @@ grep -q "ceiling 8 frames" tmp/pace_check.log || {
 grep -q "^OK" tmp/pace_check.log || { echo "FAIL: paced pass not pixel-exact";
   tail -4 tmp/pace_check.log; exit 1; }
 
+echo "--- session 21: the 68000 builds its own codebooks and palette (FINDINGS 53) ---"
+# ROADMAP P1+P2. Until now tools/bench/dlxload.py expanded the codebooks and
+# packed the palette HOST-SIDE and the rigs pushed the result into emulated RAM.
+# A player has no host. src/player/load.i does both on the 68000, out of the RAW
+# container header, and this gates it byte-for-byte against dlxload.py -- which
+# stays the reference, because what changed is where the transforms RUN, not
+# what they produce.
+#
+# Byte-for-byte and not "close enough": a wrong codebook byte is a wrong colour
+# in every block that uses that codeword, and a wrong shared LSB is a slightly
+# wrong colour that looks like a codec artefact rather than a loader bug.
+# The palette half is read back out of the PALETTE REGISTERS at $E82000, so
+# "the words reached the hardware" is part of what passes.
+#
+# NOT gated on the cycle counts, and the reason is NOT the one blit.s has. These
+# are emulated time and reproduce exactly run to run; what they are not is
+# sharp, because MAME samples them on a 1/55.46 s clock and the job takes
+# milliseconds. Nothing in the tree's cost models depends on them either. A
+# change in them is a re-derivation in FINDINGS 53, not a red light here.
+bash tools/bench/load_run.sh "$DLX" > tmp/load_gate.log 2>&1 || {
+  echo "FAIL: the load-time transforms did not pass."; tail -12 tmp/load_gate.log
+  exit 1; }
+grep -aE "^ *OK|both CPU cores|SCENE CHANGE" tmp/load_gate.log | sed 's/^ *//;s/^/  /'
+
 echo "ALL GREEN"