Closes #180.

A non-Effect/ST do block (over Maybe, Either, and friends) compiled to a
tower of bind closures. This adds a post-magic-do pass that inlines the
dictionary method at each call site so the case-of-known-constructor folds
(#177/#213/#214) can fire, and a Maybe/Either chain then collapses to
straight-line code. A size budget keeps the growth in check.

The pass runs as a specialize+dce fixpoint after magic-do, so dead-code
elimination and beta reduction had to learn to leave magic-do's lowered
Effect/ST statements alone.

What made it work

Getting the chain to actually collapse (rather than half-inline into a deeply
nested tree) took three supporting changes:

Resolve imported constructor references. A source-level Right x compiles to
a reference to the Data.Either.Right worker, whose right-hand side is a bare
Ctor node, not a lambda, so the call-site inliner leaves it in place.
propagateKnownCtorThroughLet now looks the reference up in the inline
environment to read its tag and arity. Without this an inlined bind's tag test
never folds, and Golden.LongEitherBind stayed a >180-deep if/let tree that
overflowed the Lua parser's nesting cap.

A dedicated effect-run marker. Magic-do ran a thunk by applying it to
Prim.undefined, which is also the argument PureScript passes to force an
ordinary nullary thunk. isEffectRun could not tell the two apart, so beta
reduction refused to reduce a whole class of pure thunks (superclass-dictionary
accessors, runIdentity newtype coercions) that a non-Effect monad like
State inlines, leaving them to bloat the output. Magic-do now uses its own
EffectRunArg marker, so isEffectRun is exact and those pure thunks reduce
away. This more than halved the State growth on its own.

Distribute a tag read through a conditional. An inlined comparison
(compare, >=) is an if-tree of Ordering constructors.
reduceKnownConstructor now pushes a reflectCtor read into the branches (only
when every branch folds), so the tree becomes tag-string comparisons instead of
building an Ordering table at runtime just to read the tag back off it.

Result

Across the golden corpus the net is a large reduction (the diff is about 35k
lines removed against 24k added). Realistic monadic code collapses hard:
LongEitherBind 731 to 77 lines, LongReaderBind 513 to 40,
ProfunctorDictLens 122 to 17.

The exceptions are the deep monad-transformer stress tests, where inlining a
StateT/Except bind unrolls the state threading with no sum-type tag to
fold against: LongStateBind +282, LongStackBind +277, TailRecM2Shadow +112
lines. These are 300-step or fully polymorphic stress cases, they stay correct
and load fine, and the growth is 1.3 to 1.7x (down from 8x before the effect-run
marker). Two follow-up optimizations that would shrink them further are filed
separately: Eq-through-if folding (#220) and inlining that only fires when
it pays for itself (#221).

Verification

• Full suite green (cabal test all). Every eval oracle passes, so the runtime
  output is unchanged; only the structural goldens moved.
• A focused unit test pins the constructor-reference resolution (red without the
  fix, green with it).
• fourmolu and hlint clean.