feat: create m:n relationship convenience command (C4, ADR-0045)

`create m:n relationship from <T1> to <T2> [as <name>]` generates a
junction table with one FK column per parent PK column ({table}_{pkcol},
typed via fk_target_type), a compound PK over them, and two CASCADE 1:n
relationships -- all in one do_create_table call = one undo step.
Auto-named {T1}_{T2} (optional `as`), both modes, compound-parent PKs
supported (ADR-0043). Self-referential m:n / PK-less parent / internal
junction name / name collision all refused.

Wired across every surface: grammar (separate CREATE_M2N node), worker
executor, runtime dispatch, completion ("m:n" composite), hints,
highlighting, help + usage catalog + disambiguator, and the advanced-mode
DSL->SQL teaching echo (render_create_m2n, round-trips as valid SQL).

Generalized/fixed framework assumptions the build + two /runda passes
surfaced (all behaviour-preserving for existing commands):
- simple-mode dispatch committed simple.first() unconditionally -> tries
  candidates, so `create table` no longer shadows `create m:n`.
- the completion continuation-merge was advanced-only -> runs in simple
  mode too when an entry word has >1 DSL form (gated simple_count>1).
- do_create_table now rejects internal `__rdbms_*` names (closes a
  pre-existing hole on the DSL create-table path too, not just m:n).
- usage disambiguator now recognizes the `m:n` opener.

Tests: 14 integration (tests/it/m2n.rs), 7 typing-surface matrix, echo /
highlight / usage / internal-name units. Closes C4.
2237 pass / 0 fail / 1 ignored. Clippy clean.

src/dsl/grammar/mod.rs

@@ -657,6 +657,12 @@ pub fn usage_key_for_input_in_mode(
     if source.as_bytes().get(after).is_some_and(u8::is_ascii_digit) {
         return keys.iter().copied().find(|k| k.ends_with("relationship"));
     }
+    // The `create m:n relationship` form (ADR-0045) opens with `m:n`
+    // — a letter, so the digit branch misses it, and its usage key ends
+    // `…create_m2n` (not `relationship`).
+    if source[after..].get(..3).is_some_and(|s| s.eq_ignore_ascii_case("m:n")) {
+        return keys.iter().copied().find(|k| k.ends_with("m2n"));
+    }
     // Otherwise the form word is an identifier — `column`,
     // `index`, `table`, `relationship` — matched against the
     // usage key's suffix.
@@ -706,6 +712,7 @@ pub static REGISTRY: &[(&CommandNode, CommandCategory)] = &[
     (&ddl::RENAME, CommandCategory::Simple),
     (&ddl::CHANGE, CommandCategory::Simple),
     (&ddl::CREATE, CommandCategory::Simple),
+    (&ddl::CREATE_M2N, CommandCategory::Simple),
     (&data::SHOW, CommandCategory::Simple),
     (&data::INSERT, CommandCategory::Simple),
     (&data::UPDATE, CommandCategory::Simple),
@@ -852,6 +859,13 @@ mod usage_key_tests {
             ),
             ("show data T", "parse.usage.show_data"),
             ("show table T", "parse.usage.show_table"),
+            // `create` is multi-form (table vs m:n, ADR-0045): each typed
+            // form resolves to its own usage key.
+            ("create table T with pk id(int)", "parse.usage.create_table"),
+            (
+                "create m:n relationship from A to B",
+                "parse.usage.create_m2n",
+            ),
         ];
         for (input, expected) in cases {
             assert_eq!(