contract: emission_scan — stub markers after a record token now win (codex P2); document the deliberate RouteBucketTyped method-name collision + UFCS rule (codex P2)

- classify_ddl_type no longer early-returns on record: precedence is
  global over the whole expression (Stub > RecordLink > AnyTyped >
  Typed); record<user> TODO / record<fixme> / array<record<user>> stub
  now classify as Stub instead of miscounting as real links. Stub stays
  the only early return (top precedence). +1 regression test, 3 cases.
- RouteBucketTyped: the kind/id name reuse vs RouteBucket is deliberate
  (one contract shape; blanket delegates verbatim so both resolutions
  are identical); ambiguity under a both-traits glob is a compile error
  with a UFCS fix, never silent misbehavior; rename rejected — would
  fork the shape and break deployed op-nexgen consumers. Documented on
  the trait.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MLBnPuScZy6w9di2QEjsXM

Author: claude

crates/lance-graph-contract/src/codegen_spine.rs

@@ -384,6 +384,23 @@ pub trait RouteBucket {
 /// implementor. A type that *also* needs `RouteBucketTyped` with a
 /// **different** kind must NOT impl `RouteBucket` (it would conflict).
 /// Non-Odoo targets simply skip the legacy trait and impl this one directly.
+///
+/// # Method-name collision with `RouteBucket` (deliberate — read this)
+///
+/// This trait intentionally reuses the `kind` / `id` / `id_owned` method
+/// names so the two traits carry ONE contract shape, and the blanket impl
+/// delegates verbatim to `RouteBucket` — the two resolutions are always
+/// semantically identical. The cost (codex P2, PR #632): a scope that
+/// brings BOTH traits in unqualified (e.g. `use codegen_spine::*;`) makes
+/// `bucket.kind()` ambiguous on a concrete `RouteBucket` implementor.
+/// This is a **compile error with an obvious fix, never silent
+/// misbehavior** — disambiguate with UFCS (`RouteBucket::kind(&b)` /
+/// `RouteBucketTyped::kind(&b)`, either is correct because the blanket
+/// delegates), or import only the trait you consume. Renaming the methods
+/// was rejected: it would fork the contract shape and break the
+/// already-deployed op-nexgen consumers that code against `kind()`. The
+/// tests below demonstrate the UFCS pattern where both traits share a
+/// scope.
 pub trait RouteBucketTyped {
     /// The handler-kind enum specific to this target. Must be `Copy + Eq`
     /// so it can drive dispatcher tables / `match` arms / hash keys.

crates/lance-graph-contract/src/emission_scan.rs

@@ -91,6 +91,7 @@ pub enum TypedForm {
 #[inline]
 #[must_use]
 pub fn classify_ddl_type(ty: &str) -> TypedForm {
+    let mut saw_record = false;
     let mut saw_any = false;
     let mut token_count = 0usize;
 
@@ -100,14 +101,20 @@ pub fn classify_ddl_type(ty: &str) -> TypedForm {
         }
         token_count += 1;
 
+        // Stub is the ONLY early return: it is top precedence, so nothing a
+        // later token could contain outranks it. `record`/`any` must NOT
+        // early-return — a stub marker may still follow (e.g.
+        // `record<user> TODO`, `record<fixme>`), and the documented
+        // precedence says Stub wins globally, not first-token-wins
+        // (codex P2, PR #632).
         if token.eq_ignore_ascii_case("todo")
             || token.eq_ignore_ascii_case("stub")
             || token.eq_ignore_ascii_case("fixme")
         {
             return TypedForm::Stub;
         }
         if token == "record" {
-            return TypedForm::RecordLink;
+            saw_record = true;
         }
         if token == "any" {
             saw_any = true;
@@ -118,6 +125,9 @@ pub fn classify_ddl_type(ty: &str) -> TypedForm {
         // Empty or whitespace-only expression.
         return TypedForm::Stub;
     }
+    if saw_record {
+        return TypedForm::RecordLink;
+    }
     if saw_any {
         return TypedForm::AnyTyped;
     }
@@ -263,6 +273,21 @@ mod tests {
         assert_eq!(classify_ddl_type("TODO record<any>"), TypedForm::Stub);
     }
 
+    #[test]
+    fn classify_ddl_type_stub_marker_after_record_still_wins() {
+        // Regression (codex P2, PR #632): a stub marker AFTER the `record`
+        // token must still win — precedence is global over the whole
+        // expression, never first-token-wins. Before the fix, the early
+        // return on `record` miscounted partially-stubbed record-link DDL
+        // as real links.
+        assert_eq!(classify_ddl_type("record<user> TODO"), TypedForm::Stub);
+        assert_eq!(classify_ddl_type("record<fixme>"), TypedForm::Stub);
+        assert_eq!(
+            classify_ddl_type("array<record<user>> stub"),
+            TypedForm::Stub
+        );
+    }
+
     #[test]
     fn classify_ddl_type_false_positive_guard_many_and_recording() {
         // Substring "any" inside "many" and substring "record" inside