Closes #177. The enabler for the dictionary-specialization cascade (#178/#180 build on it).

What

Two rewrite rules in optimizedExpressionM, the algebraic-type twin of the existing record-projection fold (reduceObjectProp):

• ReflectCtor (K a₁ … aₙ) over a saturated sum-type constructor application folds to K's tag string. Constant folding and the unreachable-branch rules then collapse the surrounding decision-tree test to its live branch (GHC's KnownBranch).
• DataArgumentByIndex i (K a₁ … aₙ) folds to aᵢ.

Design points

Saturation. A constructor application is the curried unary-App spine the pattern matcher builds (App (… (App (Ctor …) a₁) …) aₙ); a Ctor node holds field names, not arguments. The fold unwinds that spine and fires only at exact saturation (as many arguments as fields), so a partial application stays a function. A genuinely n-ary AppN ctor application (which #201 will introduce) is left alone until then.

Sum types only for the tag fold. Product constructors omit the $ctor row in codegen, so folding a product-type tag read to a string would invent a value the runtime reads as nil. Field reads fold for either shape, since valueᵢ rows exist for both.

Discard discipline. The issue asks for the reduceObjectProp discipline, and I read its named precedent literally: reduceObjectProp drops discarded record fields (the same call DCE makes on an unused binding), so these folds drop discarded arguments too. I checked this can't skip an Effect: effects are unrun thunks in this backend, run only when applied, so an effect that must run is the kept field, never a dropped one. The only casualties are the pure divergence or partiality that DCE already elides (and unsafePerformEffect, whose behavior under DCE is unsafe by contract and which a let-bind wouldn't save anyway). The folded value takes the read node's own annotation, not the argument's, so a Just Always-annotated foreign accessor can't leak inlinability into the result.

Verification

• Nine example cases pin the fold decisions directly (both folds, non-zero index, the collapse cascade, both declines, the argument drop, the annotation discipline).
• Two randomized properties (100 inputs each) stress the discard semantics the issue flags: across arbitrary arity, algebraic type, and argument content, a field read folds to exactly its argument (equality to the kept argument alone proves the siblings are dropped) and a sum-type tag read folds to the tag string.
• Two pipeline tests, the constructor twins of the existing "record projection after inlining", prove both folds fire end to end through the full optimizer: inlining a single-use constructor binding into a field or tag read forms the redex mid-fixpoint, the fold reduces it, and DCE drops the emptied binding.
• The shared IR generator now emits the constructor shapes. Both exp and scopedExpIn gained a saturated constructor application (one argument per field, nullary ⇒ a bare Ctor) plus reflectCtor / dataArgumentByIndex wrappers. A Ctor node binds nothing and references no scope entry, so every argument reuses the incoming scope (the same category as application / if / object), well-scoped by construction. This feeds every existing Gen.scopedExp / Gen.exp consumer (FloatIn, DCE, Uniquify, Linter, Types, and the full-pipeline Optimizer property), so ~10 property suites now fuzz constructor-shaped IR against these folds for free.
• A new property runs the full single-pass optimizedExpression over generated input (which, with the generator extension, actually fires the fold): free references stay a subset of the input's (the fold drops discarded ctor arguments, so equality would be wrong), and the result stays well-scoped. FloatIn's stricter "preserves free references" equality still holds, since floatIn only moves Lets and drops nothing.
• Full suite green (648 examples), hlint clean, and the whole build is warning-free (clean rebuild carries zero -W warnings). No golden churn: as the issue predicts, the shapes don't occur in any existing golden, because they need specialization to bring a constructor inline to a match, so the standalone effect is nil and the value lands through Lift the pure subset of foreign values into the IR: primop nodes and an allowlist-driven lifter #178/Budgeted call-site inlining of dictionary methods to collapse non-Effect/ST monadic chains #180.
• Post-review cleanup: the fold's spine unwinder turned out to be a third copy of the same helper (spine in MagicDo, a local unwind in Uncurry), so one polymorphic unwindApp moved to IR.Types and all three passes now share it; a clean build's remaining pre-existing warnings (missing local signatures, unused imports, one shadowed name, a redundant pattern App import surfaced by the generator recompile) are cleared so the build is warning-free; and the Use const hlint hint is disabled repo-wide, since a named-but-ignored lambda binder (\_whatIsDiscarded → …) documents what is dropped where const erases it.