The owner's ruling: the coherence table carries the sizes of the types
themselves, and every binder carries its size and a reference to it. This
is the first third of that — the row store, minted, filled, and read by
nobody.

Three moves, all inert by construction:

1. `build_field_types` / `build_payload_types` run FIRST in both cascade
   sites. The one real dependency edge in that cascade is
   `build_coherence_table <- build_trait_methods`; the shape tables sat
   after coherence for no reason, and the size pricing reads exactly them.
   Verified inert, not assumed: no cascade builder writes interner state a
   later one reads — each takes `&mut Interner` only to `intern`
   identifier text, and the cascade's one allocation (`alloc_impl`, inside
   `build_coherence_table`) mints an id no shape table looks at. Measured:
   `ckc sizes` and `ckc check` over all 146 apps of BOTH corpus roots,
   stdout, stderr and exit code, byte-identical before and after (noise
   floor established first: two baseline sweeps, zero difference).

2. `ProjectSizeTable` (`ck_types::arena_size::table`) — `BTreeMap<Ty,
   TypeSize>`, a pure memo over `type_size` and nothing else. `Ty` and
   never `TypeId`, because `String<64>` is not `String<128>` and both
   share one id; a `TypeId`-keyed size table is ruling 1's bug reborn as a
   cache. `BTreeMap` and never `HashMap`, because `traits_for` already
   measured what a `RandomState` key sweep costs: one unchanged directory,
   two different binaries.

3. `Tables.sizes`, filled by `sizing::price_declared_types` from the two
   shape tables' own rows — not a second CST walk, so it cannot drift from
   the walk that found those positions. Nothing reads it. `#[expect]` and
   not `#[allow]`, so the suppression itself fails the build the moment
   the first reader lands.

And the guard that should have existed before the table did: architectural
rule S1 — a `TypeSize` may only be CONSTRUCTED inside
`ck_types/src/arena_size/`. This is the `LIST_HANDLE_BYTES` lesson made
machine-readable: that constant outlived its repr, under-counted every
`List` by a word everywhere it was sized, and its doc comment cited an
enum variant no crate ever had. Prose was the half that failed. Two
exemptions, each justified, both directions checked; red-proofed on both
detection arms.

`Tables` moves to its own file: adding the size row pushed `compile/mod.rs`
over the R3 cap, and splitting is that rule's sanctioned answer — the file
that drives the compile and the record of what the type stage settled are
two different things.

Ratchets: none moved, none may — this slice changes no number.
Gates: cargo fmt clean; cargo clippy --workspace --all-targets -D warnings,
0 warnings; architecture 39/39; ck_types::arena_size::table 3/3.

@@ -42,0 +41,4 @@
+///
+/// `pub(super)` so the S1 size-construction rule (`mod sizes`) scans the same
+/// file set rather than growing a third copy of this walk.
+pub(super) fn all_production_sources() -> Vec<(PathBuf, String)> {