CPR-style worker/wrapper on results: constructed products as Lua multiple values - #280

Two golden modules and a State-shaped benchmark, compiled with the
current compiler, recording today's behavior: a function whose every
return path builds the same Tuple allocates a table per call, and every
deconstructing caller reads it apart immediately (v[1]/v[2] over a
Data_Tuple_Tuple_S_w call). The StateStep bench pins exactly one
function-body TNEW — the per-iteration pair — in the tnew census, and
its eval-facing arithmetic is cross-checked against a hand-written
multi-value ideal. The result-side worker/wrapper split turns these
shapes into direct worker calls returning multiple values; the diff of
these goldens under that change is the feature's demonstration.

Two new IR constructors expose Lua's native multiple return values:
Values is the multi-value return (return a, b), LetValues the
multi-value binding (local a, b = rhs). Note [Multi-value results]
defines the multi-value slot discipline; the WellApplied lint gains a
ValuesOutsideTail violation so a Values leaking into a single-value
position — silent Lua truncation — fails loudly at every checked pass
boundary.

LetValues is a binder form, so every scope-aware traversal learns it:
countFreeRefs/countFreeRefUsage, alphaEq (positional binder walk),
freshenBinders, Uniquify, the linter's unboundLocals/duplicateBinders
and the trailing-unused-run check, DCE (live binders keep the producing
call reachable, dead suffixes blank, an all-dead LetValues collapses to
its body), CSE (binders are block-bound names and local-slot costs;
alphaKey canonicalizes positionally), and Query.collectBoundNames. The
Lua backend lowers Values to a multi-value return and LetValues to a
multi-name local, dropping trailing unused binders.

No producer exists yet: the pipeline emits neither node, so generated
code is byte-identical. The result-side worker/wrapper split lands on
top of this.

The new Cpr pass splits every binding whose right-hand side is a single
n-ary lambda with every return path ending in one fixed saturated
constructor (Exception paths are compatible) into a worker returning
the fields as Lua multiple values plus a rebox wrapper under the
original name. Constructor tails are recognised through every
post-uncurry shape via the recogniser shared with the known-ctor folds
(resolveCtorApp, extracted to Query together with hasWholeValueRead).

The pass rewrites the deconstructing call sites itself — a let-bound
saturated call whose binder is read only through eliminating reads
becomes a direct worker call under an in-place rebox — because the
call-site inliner unwinds only unary spines and would never paste a
wrapper of an n-ary worker. Splits are gated on at least one such site;
whole-value consumers keep the wrapper. Local Let candidates split in
place per top-level site; recursive-group members with constructor-only
tails split within their group; self-tail-calling candidates, vetoed
names and constructor functions decline. Reruns re-register existing
wrappers instead of re-splitting, so the pass is idempotent.

Four optimizer rules cancel the planted reboxes in the following
fixpoint: cancelLetValuesOfValues (the revert path),
floatLetFromLetValuesRhs, floatLetValuesFromLetRhs (order-preserving
first-grouping split, feeding propagateKnownCtorThroughLet), and
sinkReadIntoLetValues (feeding reduceKnownConstructor). The call-site
inliner and the duplicatable-closed-abs guard decline bodies containing
Values: a pasted worker body would lower to a per-call IIFE.

The pass is not yet wired into the pipeline, so generated code is
byte-identical; unit tests pin the split shapes, the declines, the
rerun contract, and the GUC/WellApplied/idempotence properties.

The pass sits right after the specialize fixpoint — monadic chains are
collapsed, so constructor-tailed candidates and their deconstructing
sites are maximal — followed by a second specialize+dce fixpoint that
cancels the planted reboxes against the known-constructor folds and
drops fully-bypassed wrappers. The call-site inliner's guard widens
from worker bodies to any multi-value body: pasting a wrapper would
put its rebox in expression position, lowering to a per-call IIFE
where the shared wrapper call costs nothing.

Golden.CprResult now pins the split end-to-end: branchy$r and big$r
return their components as multiple values, every deconstructing site
binds them directly (local a, b = branchy$r(n)) with no table on the
path, and the whole-value consumers (pair, keepBranchy, the exports)
keep the reboxing wrappers. Golden.CprState is byte-identical — the
StateT dictionary bind chain is not collapsed by the budgeted inliner,
so no manifest Tuple-returning candidate exists there yet; the module
pins that boundary. Golden.UncurryCtor moves only in $cse numbering
(the post-cpr fixpoint advances the shared supply).

Bench.StateStep's function-body TNEW+TDUP count drops 1 → 0: the
per-step Tuple table is gone from the hot loop, and with step
module-internal nothing keeps the boxing wrapper alive. The trace
report moves only in line numbers — the loop was already
interpreter-bound by the curried intMod foreign, so the win is
allocation, not trace formation. Every eval/golden.txt oracle is
byte-identical.