Closes #32. Supersedes #33 by including its test module, extended with a main so the generated code is actually executed.

What was wrong

eq x y = genericEq x y on a recursive data type overflowed the Lua stack as soon as a comparison was attempted. The instance dictionary referenced itself eagerly: calling eqList dictEq rebuilt the dictionary chain, which contained eqList dictEq as a strict argument, and so on without a base case. The user's eta-expanded method definition is the documented PureScript idiom for breaking exactly this cycle, and the upstream JS backend preserves it. pslua's optimizer destroyed it: the eta reduction rule rewrites λx. M x to M, which moves the evaluation of M from every call of the lambda to the point where the lambda was constructed. In a strict target that is not semantics preserving.

There were two reasons #33 could not reproduce this. Its golden test only checked compilation and luacheck, never running the code, so this PR adds a main and an eval golden to exercise the runtime path. And with a single generic type in the module, the generic machinery is used once, so the inliner inlines it and the self-reference happens to land under another lambda. The new GenericEqTwoTypes module defines two generic-derived Eq instances, which keeps the machinery multiply used and reproduces the overflow on current main.

The fix

The eta reduction rule is removed rather than restricted, because every shape of M worth reducing is unsafe in its own way: an application may diverge (the case above); a reference turns a recursive group member f = λx. g x into the value binding f = g, which the laziness analysis ran too early to see, so nothing wraps it in runtime-lazy and g may be uninitialized; an abstraction is already covered by beta reduction. The full argument lives in Note [Eta reduction is unsound] in the optimizer.

Removing the rule surfaced a latent gap in renameShadowedNames: it only processed exports, not bindings. Eta reduction used to collapse the nested same-named lambdas that now survive into codegen, so luacheck started flagging shadowed upvalues, and a shadowed reference with a non-zero index inside a binding would crash the Lua code generator with UnexpectedRefBound. The renaming pass now covers bindings as well.

Tests

• Golden/BugListGenericEq: the module from Test generic list equality #33 plus a main; its eval golden locks list equality at runtime.
• Golden/GenericEqTwoTypes: the red test for this fix. Stack overflow before, correct output after.
• Golden/DerivedFunctor: locks the derived Functor symptom from the issue comments (map over an Either-like and a recursive Tree type). It already behaves correctly on main; the golden keeps it that way.
• A unit test pins down that the optimizer leaves λx. M x intact.
• Golden diffs across the seven affected modules change shape only: lambdas that used to be eta-reduced are now preserved. All eval goldens pass.

The remaining symptom from the issue comments, a long do block failing with "chunk has too many syntax levels", has a different root (lexical nesting of bind continuations against Lua's hard parser limit) and is tracked in #46.