Uncurry data constructor applications - #278

Closes #201.

What

The IR Ctor node now carries its field argument expressions and is saturated by construction, instead of being a childless leaf whose currying materialized only at codegen:

-- before: a childless leaf; codegen wraps it in one closure per field
Ctor ann algTy modName tyName ctorName [FieldName]
-- after: the field arguments live in the node, count always equals arity
Ctor ann algTy modName tyName ctorName [RawExp ann]

Translation emits a constructor of arity n as a manifest chain of n unary lambdas over the saturated node, the same shape a user-written curried function has, so the worker/wrapper split from #24 covers constructors with no special case:

-- data Shape = ... | Tri Int Int Int   translates to
Abs v0 (Abs v1 (Abs v2 (Ctor SumType "M" "Shape" "Tri" [Ref v0, Ref v1, Ref v2])))

• A saturated application of an arity-≥2 constructor compiles to a single n-ary worker call that builds the table with no intermediate closures (from the Golden.UncurryCtor golden, prefixes abbreviated):

  -- before                          -- after
  local Tri = function(value0)       local Tri_S_w = function(value0, value1, value2)
    return function(value1)            return { "M∷Shape.Tri", value0, value1, value2 }
      return function(value2)        end
        return { "M∷Shape.Tri",
          value0, value1, value2 }   -- site: Tri(a)(b)(c)  ~>  Tri_S_w(a, b, c)
      end
    end
  end

• A saturated arity-1 application inlines to a direct in-place table build that makes no calls at all:

  -- before                          -- after
  Data_Maybe_Just(add(x, 1))         { "Data.Maybe∷Maybe.Just", (add(x, 1)) }

• Partial applications and constructors used as first-class values (map Just xs) keep going through the curried wrapper, unchanged:

  M.Tri = function(p1)
    return function(p2)
      return function(p3) return Tri_S_w(p1, p2, p3) end
    end
  end

How

• IR.Types: Ctor carries [RawExp ann]; it is traversed by subexpressions (so DCE, uniquify, substitution and CSE handle the arguments generically) and gets an explicit alphaEq case (the == fallback is over-strict once arguments contain binders). The invariant is written down in Note [Constructor applications are saturated].
• Optimizer: the case-of-known-constructor family (Fold ReflectCtor and DataArgumentByIndex over known constructor applications (case-of-known-constructor) #177/Budgeted call-site inlining of dictionary methods to collapse non-Effect/ST monadic chains #180/Case-of-known-constructor through a let-bound scrutinee #214/Graduated @inline directives: arity=N, accessor forms, and a directives file #232) matches the bare node, and a shared resolveKnownCtorApp recognizes every reference shape a constructor value takes across the pipeline: the in-place node, the n-ary worker call the early uncurry run leaves (unwindApp does not flatten AppN, so missing this shape would silently stop the folds from firing on monadic chains), the curried unary spine, and the wrapper-to-worker delegate hop.
• Lua codegen: the Ctor case emits the positional table directly from the compiled arguments. A multi-valued expression in the final positional row (a call or ...) is wrapped in explicit parens so it adjusts to one value instead of splicing extra results into the table: Ctor … [f x] renders as { "M∷T.C", (f(x)) }, never { "M∷T.C", f(x) }.
• Linter: WellApplied additionally rejects any AppN whose head is a Ctor: the node is a value now, and a pass that forgot would emit a call on a table.
• No changes to Uncurry, DCE, FloatIn, MagicDo, Linker, Uniquify or FlattenDeepBinds: the manifest lambda chain is exactly the shape they already handle.

Measurement

New Bench.CtorBuild anchor (hot build+match loop over a three-field constructor), committed with pre-change oracles first so the diff shows the movement:

• Wall-clock on the linked artifact, same driver, old vs new compiler: LuaJIT 0.336s to 0.082s (4.1x), PUC Lua 5.1 1.048s to 0.302s (3.5x).
• LuaJIT trace report: the hot map/fold loops go from blacklisted to compiled once per-element construction stops executing FNEW. Blacklisted spots drop from 6 to 2 and compiled traces rise from 6 to 10.
• The issue names bench/micro/ctor_match.lua as the anchor; that file does not exist, so this PR adds bench/micro/ctor_build.lua (current/ideal pair) and bench/macro/ctor_build.lua instead.

Verification

• The new Golden.UncurryCtor module pins every shape the change touches (saturated arity-3 sum, arity-2 product, arity-1, nullary singletons, stored partial application, higher-order use, newtype, recursive Cons spine). Its first commit records the old curried output; the diff to the accepted state demonstrates the red-to-green movement.
• Every eval/golden.txt oracle across all 75 golden modules is byte-identical, so the change is semantics preserving end to end.
• New unit tests cover the translation shapes (lambda chain, nullary, newtype erasure), the resolveKnownCtorApp recognition shapes including the n-ary worker call and the wrapper hop, the unsaturated-application declines, and the codegen paren guard.

Known tradeoff

Inlined arity-1 sum-constructor sites each embed a copy of the "Module∷Type.Ctor" tag string, so constructor-heavy chunks grow: LongMaybeBind/golden.lua goes from 667 to 1576 lines while dropping one call per construction. The string itself is interned by Lua at load time, so the cost is chunk size, not per-value memory. Hoisting shared tags into a chunk local is a possible follow-up.