feat(ir): push case-of-case over the IfThenElse decision tree - #277

Closes #203.

Problem

The IR compiles pattern matches to decision trees of nested IfThenElse. When such a tree is consumed in a strict position it sits in expression position, and codegen wraps it in an IIFE that is allocated and called on every evaluation. For the recursive functions in Golden.LongCallbackChain and Golden.TailRecM2Shadow that means on every loop iteration.

The issue predates #180, when the tree sat directly in the condition of another if. Today the dominant shape is different: the tag-read distribution rewrites ReflectCtor over an Ordering tree into an if-tree of tag strings, so the condition holds Eq "…LT" (IfThenElse …). Seven goldens carried this shape.

Approach

Three rewrites of the same case-of-case family, all in the shared rewrite chain of optimizedExpressionM.

pushEqIntoIfBranches distributes a scalar literal compared against an if-tree into its branches: Eq lit (If c t e) becomes If c (Eq lit t) (Eq lit e), in both orientations. The guard, eqFoldsThrough, mirrors reflectFoldsThrough from the tag-read distribution: the rule fires only when every leaf of the tree constant-folds against the literal. No residual comparison can survive, and the only duplicated operand is a scalar literal. The folded leaves then meet constantFolding and the boolean-if rules, which collapse the whole condition to a flat comparison.

pushIfCondIntoBranches is the transformation as stated in the issue: IfThenElse (IfThenElse c a b) x y becomes IfThenElse c (IfThenElse a x y) (IfThenElse b x y), with the issue's guard. Either the inner branches are boolean literals, in which case the residual ifs fold right away and each outer branch survives in exactly one copy, or the outer branches are trivial by isInlinableValue. Trivial values are binder-free, so the copies cannot violate GUC. Evaluation order is preserved exactly: c, then a or b, then x or y.

reduceBooleanIf gains the four half-literal cases next to its existing two-literal collapses: if p then True else b becomes p or b, if p then False else b becomes not p and b, and the mirrored shapes likewise. The non-literal branch is a Bool too, pinned by the literal (Note [IR is assumed well-typed]), and Lua's and/or evaluate exactly what the branches evaluated, in the same order, but survive in condition position without an IIFE. This is what a pushed GT comparison collapses to when two leaves fold to False: if n < 0 then false else n ~= 0, which now flattens to not (n < 0) and n ~= 0.

Two supporting changes ride along. The scalar-literal Eq cases of constantFolding are factored into foldEqLiterals and shared with the eqFoldsThrough guard, so the guard and the fold cannot drift apart. And foldPrimBinOp gains the identity folds a and true → a and a or false → a: an early and/or fold can catch a branch whose literal only appears after a later inlining round, and without the identities that ceremony survives to the output. The annihilator duals (a and false, a or true) stay unfolded, since collapsing them would skip evaluating a.

Verification

Unit tests pin all three rewrites. The LongCallbackChain microcosm folds to a flat comparison end to end (both orientations) and the GT microcosm to a flat boolean expression, a non-foldable leaf declines, trivial outer branches push while non-trivial ones stay put, each half-literal shape folds to its operator while an if with no literal branch stays, and the literal-branches arm of the condition push is exercised by direct rule application. That arm is unreachable through optimizedExpression, where reduceBooleanIf collapses two-literal inner ifs bottom-up before the outer node is inspected.

Ten goldens change, .ir and .lua only. The condition becomes a flat comparison in CharLiterals, FieldCaching, LongCallbackChain and TailRecM2Shadow: if n < 0 then instead of if "…LT" == (function() … end)() then. The GT comparisons in Loopification, Primops and UncurryEffect flatten to not (n < 0) and n ~= 0. The generic-equality chains in BugListGenericEq, GenericEqTwoTypes and StringCodePoints collapse their boolean elseif ladders into and/or chains.

Eval goldens are byte-identical. The full suite passes clean and across four extra Hedgehog seeds.

The golden luacheck run now ignores W581, which suggests rewriting not (x < y) to x >= y. That flip is the NaN-unsafe inverse codegen deliberately never emits (the printer negates == to ~= because it is exact, and keeps not over < for the same reason), so the warning has no actionable fix.