embedder: per-type adapter tables, not per-element camelCase and scans (#261)

[lannbot]

The second half of #261's per-element cost, after #263 fixed the layout half. #261 attributed ~20% of the boundary cost to runtime/src/embedder/values.ts.

What was per-element that shouldn't have been

Both directions (toHost and fromHost) recomputed pure functions of the type on every element:

• checkNoCollisions(t, t.fields.map((f) => f.label), ...) — the function is correctly memoized on a WeakSet and early-returns, but both callers built its labels argument with a fresh .map() first. An array allocated per record per element, purely to be discarded by the early return.
• camelCase(f.label) per field per element, and per label in both flags arms. camelCase splits, maps and joins — three allocations each.
• t.cases.find(c => c.label === label) per element, linear over every case. bench/boundary: a compound-element-type lane (#261) #262's bench schema has 16 cases; the consumer schema behind cabi: compound element types recompute layout per element and per field — ~5 µs/element for a stream<variant-of-records>; 2.6x from memoizing four pure functions #261 has 17.
• t.labels.includes(v) per element in fromHost's enum arm.

The change

Four WeakMaps keyed on the type object's identity — record (cached labels array plus per field {label, js, type, isOption, optionInner}), variant case lookup, enum label set, flags JS names. Same justification as the checkedLabels WeakSet directly above them in the same file: type objects are stable for the lifetime of a loaded plan, so this is a one-time cost per type and the tables die with the plan.

Semantics preserved

• checkNoCollisions is untouched — it still caches only on success, still throws on every call for a colliding label set, and still reports the calling site's where. It just gets the cached array instead of a fresh one.
• The variant table is first-wins on a duplicated label, because that is what the find it replaces did. Deliberately NOT cabi's caseIndexOf (added in cabi: one cached layout node per type, not a walk per element per field (#261) #263), which maps a duplicate to -1 because the scan it replaced asserted on exactly one match. The two sites had different pre-existing behavior; each keeps its own, and the comment says so, so nobody later "deduplicates" them into a behavior change.
• No error message literal is in the diff. Enum's "expects one of ..." still reads t.labels directly, so its ordering is the source array's.
• Field and flags iteration order is the source arrays' — the internal record objects are built by property insertion and Object.keys order is observable.

Deliberately not fixed here

single() and tagged() each allocate per variant per element (Object.keys, a fresh result object). That is real, but removing it means changing the value shape the CABI and embedder layers exchange — a contract question that belongs in #8's ledger, not in a hoisting PR.

Measured

#262's lane, deno, n=10000, interleaved before/after (stash, rebuild bundle, measure, unstash, rebuild, measure), medians of paired differences rather than of arms — the box is noisy and single-run ratios on it are not trustworthy.

• lower-ops: improved in every pair, ~9%
• lift-ops: noisier, ~10% by median paired difference

Both land around −80 ns/element. The gain scales with case count and field count, so a wider schema than the bench's sees more.

Gates

just check, just test-conventions (32 passed, goldens byte-identical), just test-runtime (696 passed), just conformance (0 failed, 0 stale xfails). No contract change, no published-surface change, no version bump.