Lift the *.Uncurried mk wrappers to n-ary function definitions (#227) - #229

Closes #227.

#226 lifted the run half of the uncurried wrappers: a saturated runFn3 add3 1 2 3 compiles to add3(1, 2, 3). The constructors stayed opaque FFI, though, and they undid much of the win. add3 = mkFn3 \a b c -> a + b + c still emitted as mkFn3(function(a) return function(b) return function(c) … end end end), uncurried on the outside but re-curried on the inside via fn(a)(b)(c), so every call of a Fn3 built this way allocated two intermediate closures. This PR lifts the mk half. The definition now compiles to function(a, b, c) return a + b + c end with no closures at all, and the mk* accessors disappear from the emitted FFI tables the same way the run* ones did in #226.

Changes

1. Lift the mk wrappers (ForeignLift). Two shapes join the translatable subset. A multi-parameter function literal lifts to a single n-ary AbsN, provided every parameter is named and the names are pairwise distinct: a vararg declines, and so does a duplicate name, because Lua binds the body's reference to the last same-named parameter and an AbsN would silently miscompile it. A nullary call fn() (the trailing effect run of the mk{ST,Effect}FnN wrappers) lifts to an application of the EffectRunArg marker, the same shape magic-do emits; codegen erases it back to an empty argument list. The literal-head arity guard from #226 stays exact, with the marker counting as one argument, so a thunk head passes and any wider literal declines. mkFn2…mkFn10, mkSTFn1…mkSTFn10, and mkEffectFn1…mkEffectFn10 join the allowlist. runFn0/mkFn0 stay off it by policy, not liftability: their bodies force a pure Fn0 with a nullary call, which must not be marked an effect run.

2. Guard the allowlist against lifting the Effect/ST core. With nullary calls translatable, the core (Effect.bindE/pureE, Control.Monad.ST.Internal.bind_/pure_) becomes technically liftable, and the allowlist Haddock now warns the broader-allowlist follow-up (#187) off it. Magic-do recognises bind chains by name, so an inline-always core would be inlined away during the optimizer fixpoint, which runs before magic-do, and that recognition would go blind: no flat do-chunks, and none of the chunked statement sequences that keep the output under Lua's local-variable limits (#19). Lifting the core behind a marker magic-do understands is tracked in #228.

Before / after

Pure definitions collapse to n-ary literals, including the point-free mulByFn = mkFn2 mul, whose wrapped function arrives through dictionary resolution rather than as a literal lambda:

-- before:
M.Golden_UncurriedLift_Test_add3 = M.Data_Function_Uncurried_foreign.mkFn3(function( a )
  return function(b) return function(c) return a + b + c end end
end)

-- after:
M.Golden_UncurriedLift_Test_add3 = function(a, b, c)
  return a + b + c
end
M.Golden_UncurriedLift_Test_mulByFn = function(a, b)
  return a * b
end

An effectful body whose thunk head is not a literal erases the marker into a direct force:

M.Golden_UncurriedLift_Test_sumST = function(a, b)
  return M.Control_Monad_ST_Internal_applicativeST.pure(a + b)()
end

One shape keeps a residual closure. A do-block body (logTwice = mkEffectFn2 \a b -> do …) is a statement sequence, and the codegen thunk fusion from #226 only covers single-call bodies, so the run of the magic-do chunk emits as an IIFE inside the n-ary literal: one closure per call, down from the wrapper's two. A tail-position IIFE collapse in the Lua optimizer would finish the job; #230 tracks that as optimizer work independent of the lifter.

The Data.Function.Uncurried, Effect.Uncurried, and Control.Monad.ST.Uncurried foreign tables are gone from the golden output entirely.

Verification

The lifter specs were written first and red: five new positive shapes (mkFn2, mkEffectFn2, mkSTFn1, a bare multi-parameter literal, a nullary call) plus new declines (a vararg, duplicate parameter names, an under-applied multi-parameter head). The UncurriedLift golden gains the mulByFn case, with its hand-written eval oracle line (48) added before any run; the checked golden pipeline lints scoping, uniqueness, and well-appliedness at every pass boundary. Full cabal test all is green (718 examples), the spec suite was repeated on three fresh Hedgehog seeds, luacheck reports no errors, and the bench FNEW census is unchanged (the bench modules use no mk* wrappers).