iter mq.3: retire MethodNameCollision + multi-class E2E + DESIGN.md sync

Closes the module-qualified-class-names milestone. Deletes the
workspace-load workaround; the two-libraries case now resolves via
type-driven dispatch at the call site with explicit qualifier as the
LLM-author's disambiguation tool. Resolves both mq.2 known-debt items
(active_declared_constraints plumbing, (class,method) re-key). New
synth warnings channel emits class-method-shadowed-by-fn at all three
fn-precedence branches per spec section Class-fn collisions. Three new
E2E fixtures + integration tests cover the ambiguous, qualified, and
class-fn-shadow trajectories. DESIGN.md class-names paragraph rewritten,
new section Method dispatch added. Roadmap P2 marked done, milestone-24
unblocked for re-brainstorm.

9/9 tasks. 545 tests green. bench/compile_check.py + cross_lang.py
exit 0; bench/check.py exit 1 (2 noise-class regressions, runtime
uncoupled to typecheck iter).

crates/ail/src/main.rs

@@ -1198,25 +1198,6 @@ fn workspace_error_to_diagnostic(
                 "var": var,
             })),
         ),
-        W::MethodNameCollision {
-            method,
-            kind,
-            first_origin,
-            second_origin,
-        } => Some(
-            ailang_check::Diagnostic::error(
-                "method-name-collision",
-                format!(
-                    "method name `{method}` collides ({kind}): defined in `{first_origin}` and `{second_origin}`"
-                ),
-            )
-            .with_ctx(serde_json::json!({
-                "method": method,
-                "kind": kind,
-                "first_origin": first_origin,
-                "second_origin": second_origin,
-            })),
-        ),
         W::MissingSuperclassInstance {
             class,
             superclass,

crates/ail/tests/mq3_multi_class_e2e.rs

@@ -0,0 +1,110 @@
+//! mq.3.6: end-to-end coverage of the post-`MethodNameCollision`-
+//! retirement multi-candidate dispatch path. Three positive fixtures
+//! exercise the three trajectories from the milestone spec
+//! §"Data flow":
+//!
+//! - Trajectory C — ambiguous bare-method call with both candidate
+//!   classes shipping `Show Int`. Typecheck rejects with
+//!   `ambiguous-method-resolution`.
+//! - Trajectory E — explicit qualifier `<module>.<Class>.<method>`
+//!   resolves cleanly to the named class.
+//! - Class-fn shadow — bare-method call where both a class method and
+//!   a free fn of the same name exist. Fn wins per lookup precedence;
+//!   `class-method-shadowed-by-fn` warning fires so the LLM-author
+//!   sees the shadow.
+//!
+//! Each test invokes `ail check --json <entry>` and asserts on the
+//! diagnostic stream's `code` field. Stdout / runtime behaviour is
+//! out of scope here — the dispatch path is a check-time concern.
+
+use std::path::PathBuf;
+use std::process::Command;
+
+fn ail_bin() -> PathBuf {
+    PathBuf::from(env!("CARGO_BIN_EXE_ail"))
+}
+
+fn examples_dir() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("..")
+        .join("..")
+        .join("examples")
+}
+
+fn run_ail_check_json(entry: &str) -> std::process::Output {
+    Command::new(ail_bin())
+        .args(["check", "--json", examples_dir().join(entry).to_str().unwrap()])
+        .output()
+        .expect("ail binary must launch")
+}
+
+/// mq.3.6 (Trajectory C): bare `show 42` in a workspace with two
+/// `Show` classes (modA and modB) each shipping `Show Int` is
+/// genuinely ambiguous. `ail check` rejects with
+/// `ambiguous-method-resolution` and names both candidate classes.
+#[test]
+fn mq3_two_show_ambiguous_fires_ambiguous_method_resolution() {
+    let out = run_ail_check_json("mq3_two_show_ambiguous.ail.json");
+    assert!(
+        !out.status.success(),
+        "expected check to reject ambiguous dispatch; stdout={} stderr={}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr),
+    );
+    let stdout = String::from_utf8(out.stdout).expect("stdout is utf-8");
+    let diags: serde_json::Value =
+        serde_json::from_str(&stdout).expect("--json mode emits a JSON array on stdout");
+    let arr = diags.as_array().expect("diagnostics is a JSON array");
+    assert!(
+        arr.iter().any(|d| d["code"] == "ambiguous-method-resolution"),
+        "expected `ambiguous-method-resolution` diagnostic; got {stdout}",
+    );
+    // Both candidate classes named in the diagnostic so the author
+    // knows which qualifiers to choose from.
+    assert!(
+        stdout.contains("mq3_two_show_ambiguous_a.Show"),
+        "expected candidate A in diagnostic; got {stdout}",
+    );
+    assert!(
+        stdout.contains("mq3_two_show_ambiguous_b.Show"),
+        "expected candidate B in diagnostic; got {stdout}",
+    );
+}
+
+/// mq.3.6 (Trajectory E): explicit qualifier
+/// `mq3_two_show_ambiguous_a.Show.show 42` disambiguates the same
+/// workspace as the ambiguous fixture. Typecheck succeeds.
+#[test]
+fn mq3_two_show_qualified_resolves_clean() {
+    let out = run_ail_check_json("mq3_two_show_qualified.ail.json");
+    assert!(
+        out.status.success(),
+        "expected check to succeed with explicit qualifier; stdout={} stderr={}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr),
+    );
+}
+
+/// mq.3.6 (class-fn shadow): bare `myeq 1 2` in a workspace with
+/// `class MyEq { myeq }` in one module and `fn myeq` in another
+/// resolves to the fn per lookup precedence. Typecheck succeeds AND
+/// the structured warning `class-method-shadowed-by-fn` fires so the
+/// LLM-author sees the shadow.
+#[test]
+fn mq3_class_eq_vs_fn_eq_fn_wins_with_warning() {
+    let out = run_ail_check_json("mq3_class_eq_vs_fn_eq.ail.json");
+    assert!(
+        out.status.success(),
+        "expected check to succeed (fn wins); stdout={} stderr={}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr),
+    );
+    let stdout = String::from_utf8(out.stdout).expect("stdout is utf-8");
+    let diags: serde_json::Value =
+        serde_json::from_str(&stdout).expect("--json mode emits a JSON array on stdout");
+    let arr = diags.as_array().expect("diagnostics is a JSON array");
+    assert!(
+        arr.iter().any(|d| d["code"] == "class-method-shadowed-by-fn"),
+        "expected `class-method-shadowed-by-fn` warning; got {stdout}",
+    );
+}

crates/ail/tests/typeclass_22b2.rs

@@ -33,14 +33,17 @@ fn class_method_is_in_module_globals() {
     let mod_globals = globals
         .get("test_22b2_class_method_lookup")
         .expect("module globals present");
+    // mq.3: ModuleGlobals accessors are tuple-keyed by (class, method).
+    // Pre-mq.3 callers passed the bare method name only; post-mq.3 they
+    // must disambiguate by class.
     assert!(
-        mod_globals.has_class_method("show"),
-        "class method `show` must appear in module globals"
+        mod_globals.has_class_method("test_22b2_class_method_lookup.Show", "show"),
+        "class method `show` (in class `Show`) must appear in module globals"
     );
     // mq.1: class_method_class returns the qualified form
     // `<defining_module>.<Class>`.
     assert_eq!(
-        mod_globals.class_method_class("show"),
+        mod_globals.class_method_class("test_22b2_class_method_lookup.Show", "show"),
         Some("test_22b2_class_method_lookup.Show"),
         "class method `show` must remember its class is `Show` (qualified post-mq.1)"
     );
@@ -65,8 +68,8 @@ fn class_method_entry_carries_full_metadata() {
         .get("test_22b2_class_method_lookup")
         .expect("module globals present");
     let cm_entry = mod_globals
-        .class_method("show")
-        .expect("class method `show` must be registered");
+        .class_method("test_22b2_class_method_lookup.Show", "show")
+        .expect("class method `show` (in class `Show`) must be registered");
 
     assert_eq!(
         cm_entry.defining_module, "test_22b2_class_method_lookup",

crates/ail/tests/typeclass_22b3.rs

@@ -483,7 +483,16 @@ fn rewrite_walker_skips_locally_shadowed_class_method() {
     let entry = examples_dir().join("test_22b3_shadow_class_method.ail.json");
     let ws = ailang_core::load_workspace(&entry).expect("load");
     let diags = ailang_check::check_workspace(&ws);
-    assert!(diags.is_empty(), "fixture must typecheck: {:?}", diags);
+    // mq.3: this fixture intentionally shadows the class method `show`
+    // with a local `let show = "shadow"`, which fires the new
+    // `class-method-shadowed-by-fn` warning. The warning is an
+    // expected correct consequence; filter it out so the assertion
+    // still pins "no errors / no other warnings".
+    let unexpected: Vec<_> = diags
+        .iter()
+        .filter(|d| d.code != "class-method-shadowed-by-fn")
+        .collect();
+    assert!(unexpected.is_empty(), "fixture must typecheck: {:?}", unexpected);
 
     let ws = ailang_check::monomorphise_workspace(&ws).expect("mono");