feat(codegen): switch the lowering walk from &Term to typed &MTerm (mir.1b)

Atomic completion of spec iteration mir.1 (docs/specs/0060-typed-mir.md):
codegen now consumes the typed MIR produced by `lower_to_mir` instead of
re-deriving types from the bare `ast::Term`. Every codegen helper that
took `&Term` (lower_term, lower_app, drop.rs, match_lower.rs) takes
`&MTerm` and reads each node's checker-proved type off `MTerm::ty()`.
The build path is `Workspace -> elaborate_workspace -> MirWorkspace ->
lower_workspace`; the public `lower_workspace*` entry points and their 18
call sites thread `&MirWorkspace`. The codegen-side type re-derivers
`synth_with_extras` + `synth_arg_type` (and the `builtin_ail_type` /
`builtin_effect_op_ret` mirror tables) are deleted — grep-clean. The
three re-derivers the spec keeps until mir.2/mir.3 (`type_home_module`,
`is_static_callee`, the second `infer_module_with_cross`) stay.

The mechanical Term->MTerm match-arm conversion was straightforward and
compiler-enforced. The substance was a set of producer-side correctness
gaps that only surface once codegen reads `MTerm::ty()` and once the
build path re-synthesises the post-mono AST through the canonical
`synth` (which, unlike the old codegen, fully re-unifies). Each was
root-caused against a failing e2e fixture:

1. `qualify_local_types` stripped fn-type modes (rebuilt `Type::Fn` with
   empty `param_modes` / `Implicit` `ret_mode`), so a monomorphised
   polymorphic intrinsic (`RawBuf.set`) lost its `Own` ret-mode and the
   owned temporary leaked at the call site. Made mode-preserving, like
   its sister `qualify_workspace_types` and `Subst::apply` (449df13).

2. `lower_to_mir::synth_pure` synthesises each node in isolation, so a
   nullary polymorphic ctor (`Nil : List<a>`) left its element type an
   unbound `$m` metavar that the canonical synth never pins. Codegen's
   mono unifier (`unify_for_subst`) already has a wildcard for exactly
   this — `$u`, the spelling the now-deleted codegen synth used — so the
   typed-MIR boundary normalises every residual `$m` to `$u` once
   (`wildcard_residual_metavars`), rather than teaching each consumer to
   tolerate a raw metavar.

3. The class-method mono arm (`synthesise_mono_fn`) substituted the
   registry-canonical *qualified* instance type into a method appended to
   the instance's own module, minting a `show_user_adt.IntBox` param
   against a bare-`IntBox` body. Localised to bare before substitution,
   symmetric to the free-fn arm (600565d).

4. Monomorphisation synthesises *downward* class-dispatch references —
   prelude's `print__<IntBox>` names the instance module `show_user_adt`
   that prelude never imports. The post-mono re-synth in `lower_module`
   seeds every workspace module name as an identity import (excluding the
   current module, to keep own types bare) so the qualified-var path
   resolves these; the canonical `synth` used by `check_workspace` stays
   strict.

5. Post-mono, a cross-module callee can name the consumer's *own* ADT
   qualified (`show_user_adt.IntBox`) where the consumer synthesises it
   bare — a spelling split that cannot exist pre-mono (the param is
   polymorphic there). synth's App arm strips the current module's own
   qualifier from both sides before unifying (`strip_own_module_qual`),
   a no-op pre-mono.

Acceptance: whole workspace suite green (698 tests); `e2e` 98/98 and
`show_print_e2e` 3/3; `synth_with_extras`/`synth_arg_type` grep-clean in
codegen; #51/#53 fixtures build and run; lower_to_mir_ty pins green. The
#49 heap-Str loop-binder leak remains ignored (lifts at mir.4).

Builds on the standalone producer fix (600565d, free-fn own-ADT
localisation) and the two standalone mode-preservation fixes
(449df13 Subst::apply); those landed separately as they are
independently correct and inert on the old codegen.

crates/ailang-codegen/tests/embed_record_layout_pin.rs

@@ -25,8 +25,9 @@ fn load(file: &str) -> Workspace {
 
 fn lower_carrier_ir() -> String {
     let ws = load("embed_record_layout_carrier.ail");
+    let mir = ailang_check::elaborate_workspace(&ws).expect("elaborates");
     ailang_codegen::lower_workspace_with_alloc(
-        &ws, ailang_codegen::AllocStrategy::Rc).unwrap()
+        &mir, ailang_codegen::AllocStrategy::Rc).unwrap()
 }
 
 #[test]

crates/ailang-codegen/tests/embed_staticlib_lowering.rs

@@ -20,8 +20,9 @@ fn load(file: &str) -> Workspace {
 #[test]
 fn staticlib_emits_forwarder_no_main() {
     let ws = load("embed_backtest_step.ail");
+    let mir = ailang_check::elaborate_workspace(&ws).expect("elaborates");
     let ir = ailang_codegen::lower_workspace_staticlib_with_alloc(
-        &ws, ailang_codegen::AllocStrategy::Rc).unwrap();
+        &mir, ailang_codegen::AllocStrategy::Rc).unwrap();
     assert!(!ir.contains("define i32 @main()"),
         "staticlib IR must not emit the @main trampoline");
     assert!(ir.contains("@backtest_step("),
@@ -55,8 +56,9 @@ fn staticlib_emits_forwarder_no_main() {
 #[test]
 fn staticlib_record_forwarder_is_ptr_passthrough() {
     let ws = load("embed_backtest_step_record.ail");
+    let mir = ailang_check::elaborate_workspace(&ws).expect("elaborates");
     let ir = ailang_codegen::lower_workspace_staticlib_with_alloc(
-        &ws, ailang_codegen::AllocStrategy::Rc).unwrap();
+        &mir, ailang_codegen::AllocStrategy::Rc).unwrap();
     // record param + ret cross as bare ptr; ctx leading; M2 TLS shape.
     assert!(ir.contains("define ptr @backtest_step(ptr %ctx, ptr %a0, double %a1)"),
         "record fwd: ptr ret, leading ptr %ctx, ptr record param, double sample;\nIR:\n{ir}");
@@ -75,8 +77,9 @@ fn executable_target_still_emits_main() {
     let ws = load("embed_backtest_step.ail");
     // Default executable lowering is unaffected by the new field;
     // backtest has no `main`, so exe-target lowering still rejects.
+    let mir = ailang_check::elaborate_workspace(&ws).expect("elaborates");
     let err = ailang_codegen::lower_workspace_with_alloc(
-        &ws, ailang_codegen::AllocStrategy::Rc).unwrap_err();
+        &mir, ailang_codegen::AllocStrategy::Rc).unwrap_err();
     assert!(format!("{err}").contains("has no `main` def"),
         "exe target must still surface MissingEntryMain; got {err}");
 }

crates/ailang-codegen/tests/eq_primitives_pin.rs

@@ -6,7 +6,7 @@
 //! extension-dispatching superset), so the post-iter `.ail` corpus is
 //! loaded from Form A rather than the deleted `.ail.json` siblings.
 
-use ailang_check::{check_workspace, monomorphise_workspace, Severity};
+use ailang_check::elaborate_workspace;
 use ailang_codegen::lower_workspace;
 use ailang_surface::load_workspace;
 use std::path::Path;
@@ -21,13 +21,8 @@ fn eq_primitives_smoke_path() -> std::path::PathBuf {
 fn lower_eq_primitives_smoke() -> String {
     let entry = eq_primitives_smoke_path();
     let ws = load_workspace(&entry).expect("load workspace");
-    let diags = check_workspace(&ws);
-    assert!(
-        diags.iter().all(|d| !matches!(d.severity, Severity::Error)),
-        "unexpected check_workspace errors: {diags:?}"
-    );
-    let ws = monomorphise_workspace(&ws).expect("monomorphise");
-    lower_workspace(&ws).expect("lower")
+    let mir = elaborate_workspace(&ws).expect("elaborates");
+    lower_workspace(&mir).expect("lower")
 }
 
 /// integration with the auto-loaded prelude. Compiling a