Prepare the frontend world once for the whole census

[gunbai-bot]

The affordability half of the executing 15-member census. Deliberately not the census itself —
see What does NOT land.

What lands

One prepared world. The census rebuilt the world fifteen times: classify_source called
dag_lex_rules() and dag_grammar() itself, so every member revalidated the grammar and
recomputed the FIRST/nullable analysis for a grammar that does not vary between members.
take_frontend_census prepares once and classifies every rostered member through that one world.

The seam already existed and this reuses it rather than inventing one: 02_parse's
prepared_grammar_carrier_note records that prepare_grammar exists so a K-module walk validates
once instead of K times, with parse_module_prepared as the per-module half. parse_module is
the composition of the two, which is right for a single call and wrong for a census.

Three receipt states, not a list. FrontendCensusReceipt = CensusTaken | CensusRefusedAtWorld | CensusRefusedAtReconciliation. A refused world is a fact about the world rather than about any
member — reporting it as fifteen ParseRefused stages would say fifteen members failed to parse
when none was ever examined. CensusTaken is reachable only through the exact-reconciliation arm,
so an unreconciled population cannot present as a census.

classify_source stays lazy and returns an Outcome. The laziness is a budget fact: a lex
refusal is decided before any grammar is consulted, which is the only reason the LEX claim in the
durable witness executes inside the fast lane. The Outcome is because preparation can refuse and
no FrontendStage honestly represents that. Both paths share one pipeline authority
(classify_after_lex), so there is no second copy of the stage chain.

Roster identity is a structural hash fold over the paths in order, parameterized by the rows
so discrimination is testable — an identity that can only see the live roster is unfalsifiable.
Three controls: stable across calls, separates different paths, separates reordered rows.

What does NOT land

The census still does not execute as a required gate, and no claim here runs
take_frontend_census. Doing so reads fifteen live files and builds the grammar once, and one
grammar construction alone was previously measured over the five-second budget.

This increment removes a fifteen-times multiplier from a cost that may still exceed the budget by
itself. I have not measured the result — this container has no claim_batch binary, so any
figure stated here would be invented rather than observed. The enrollment decision is therefore
deferred to a measurement, not to an opinion. If the prepared census is still over budget the
answer is realization or materialization, not a long/ directory and not silence.

Known limit, stated rather than solved

Roster identity does not cover the labels. The only Symbol-to-text surface in the tree is
v2.std.compilers.lexing symbol_lexeme, whose .dag body is a self-recursive stub reachable
only through host interception — the shape DESIGN records as deleted elsewhere for that reason.
Grounding a provenance claim on it would be worse than the gap. Labels are separately constrained
by verify_roster, which refuses duplicates; the one case this identity does not separate is two
rosters differing only by a permutation of labels over identical paths in identical order.