Closes #108.

Problem

FlattenDeepBinds flattens deep nesting that would otherwise overflow Lua 5.1's parser-nesting cap (~200 levels). It recognised deep chains by instance name — Control.Bind.bind/discard, or a Bind dictionary shape. That recognition is precise but brittle and incomplete:

• The State-transformer miss fixed in Flatten deeply-nested non-Effect/ST do-blocks #107 was exactly a recognition gap.
• Applicative chains (ado/apply, =<</bindFlipped) carry their depth in a value-argument position rather than a trailing lambda, and were never covered — they fell through to a NestingTooDeep compile error where they could compile.

Change

Replace name-anchored recognition with structure-anchored recognition, and add a second strategy dispatched by where the depth lives.

Strategy A — continuation lambda-lifting (existing, name-gate removed). Fires on any f action (\x -> ...) chain, not just a recognised bind. This deletes the entire recogniser/resolution machinery (isBindHead, headReducesToBind, denotes, isBindDict, peelAlias, the Control.Bind name constants, mkResolve/topLevel/letLocals, and the threaded resolve parameter — ~200 lines). Existing bind goldens are unchanged: same structural shape → identical lambda-lift. Now also covers non-bind CPS / bracket / with-style nesting.

Strategy B — application-spine sequentialisation (new). Handles contiguous App spines whose depth is in a value-argument position: ado/apply, =<</bindFlipped, deep left-associated <>, any nested call spine. It peels the deepest application path and rebuilds it bottom-up — Lua's evaluation order for these spines — sealing the accumulator into a fresh $tmp local every segmentSize frames.

Segmentation (not full A-normalisation) is required because there are two Lua 5.1 per-function limits: a naive full ANF flattens the parser nesting but then overflows the 200-local cap (~300 locals for a 300-deep spine). Segmenting every segmentSize frames bounds both at once: each segment nests ≤ segmentSize deep and the local count is ≈ depth / segmentSize.

Dispatch tries A first; a bind chain hides its depth under lambdas, so its application-spine depth is tiny and B only ever sees the remaining deep App spines — the two are naturally disjoint.

What is not replaced

• MagicDo (Effect/ST imperative lowering) is a different kind of solution (local x = m() is only valid where computations are thunks); kept, still runs first, still consumes Effect/ST chains before the general breaker sees them.
• NestingCheck (post-codegen backstop) is unchanged.
• Deep case trees (nested if/then/else) need branch- and laziness-aware hoisting; left on NestingCheck as a residual follow-up.

Soundness

Lua is strict, so every App callee and argument is evaluated regardless of use. Strategy B sequentialises strict positions in evaluation order and never hoists across Abs/branch boundaries, so it preserves evaluation order and divergence. Strategy A only relocates continuations and forwards live variables by name — it never reorders, drops, or duplicates a call. The pass runs after renameShadowedNames, so the freshly-named $kont/$tmp binders shift no de Bruijn index.

Tests

• Structural-recognition unit: a chain whose head is not a bind now flattens (proves the name-gate is gone).
• Strategy-B units + 200-example Hedgehog properties for both left- and right-nested spines: free-reference preservation, idempotence, nesting-depth reduction.
• Three runnable goldens whose generated Lua loads and evaluates under stock Lua 5.1 (eval oracle):
  • LongCallbackChain (A) — recursive-guarded non-bind CPS combinator, ~300 deep → 300.
  • LongApplyChain (B) — *> applicative spine, ~300 deep → (Just 300).
  • LongBindFlipped (B) — =<< spine, ~300 deep → (Just 301).

Full suite green (313 examples, 0 failures); no existing golden churned. fourmolu/hlint clean.