Stop two compile-time code-size blowups that exhaust the SBCL heap

[pyrex41]

Two independent, pre-existing defects that made SBCL exhaust its 1GB dynamic
space inside the compiler on ordinary Shen programs. Both were found while
running a downstream four-port conformance suite.

1. Accessor chains rebuilt at every conditional level (ffceeec)

The kernel's pattern compiler (shen.shendef->kldef, shared by all four ports)
re-derives the full hd/tl spine per pattern element: a 7-key record pattern
becomes a 12,441-node KL form, 222 levels deep. shen-cl's KL→CL translation is
linear and not at fault — the death was SBCL compiling the result, consing
802MB for one defun.

New CL→CL pass shen-cl.bind-accessor-chains in src/primitives.lsp, applied
only in |eval-kl|. Each CAR/CDR step is computed once via inline SETQ
at first occurrence (SETQ returns the value, so evaluation order and results
are unchanged). Reuse only along guaranteed-evaluated paths — never across
COND clauses, IF branches, OR alternatives, or trap-error; only chains rooted
at lexical variables; closure bodies untouched. compiled/*.lsp byte-identical.

Repro compile: 802MB / 0.9s → 10.5MB / 0.01s. A 64-field record, 8-16x past
the old death point, now compiles in the default 1GB image.

2. The factoriser spliced its fallthrough twice — exponentially (8be0b2d)

shen-cl.factorise-cases spliced factored-remaining into both the inner
true fallthrough and the outer clause list. That is shared structure in
memory, but compile-expression walks the tree recursively, so each
factorisation level expanded the next level's two splices: generated code
grew 2^groups.

Measured (groups = consecutive 2-clause runs sharing a first test — what any
plain dispatch table produces): 8 groups 8,173 CL nodes; 12 → 131,053; 16 →
2,097,133; 18 → 8,388,589, from KL input growing a flat 24 nodes per group.
End to end, a 33-clause function was fatal: heap exhaustion after 446s and
938MB peak.

The remaining clauses are now emitted once, as the label body of a
%%let-label join that both fallthrough paths %%goto-label to (compiles to
TAGBODY/GO) — the same mechanism the kernel's original factorise-defun
extension used, whose machinery src/compiler.shen had retained unused. Clause
order, evaluation order, and fallthrough are unchanged; zero runtime cost.
Growth is now linear (~48 nodes/group): the fatal 16-group case compiles in
0.03s / 47MB, and a 401-clause function in 0.04s.

Also fixed: shen-cl.acc-walk skipped TAGBODY wholesale, which would have
silently disabled fix 1 inside factored dispatch code. It now walks compound
tagbody statements with the tagbody's entry env.

Verification

• Kernel suite 134/134 before and after. Port runtime suite 131/131 before,
  136/136 after (+5 regression assertions).
• Dispatch semantics cross-checked byte-identical to shen-go and shen-rust:
  exact hits, group-miss fallthrough, total miss.
• Both passes cooperate: 16 wide-record clauses across 8 factored groups
  compile in 1.4s / 392MB, on par with an unfactored control.
• No heap bump was needed or taken. Note boot.lsp saves with
  :save-runtime-options t, which would block a runtime override anyway.
• Downstream: all eleven four-port conformance suites pass exact-golden.

🤖 Generated with Claude Code