ADR-0024 Phase D (full): schema-aware value typing

Schema-aware typed value slots — the central design claim of
ADR-0024 §Phase D. Insert / update / delete value slots now
dispatch on the user-facing column type at parse time, rejecting
mis-shaped input with localised wording instead of waiting for
the bind-time error.

What changed:

**SchemaCache extension** (`src/completion.rs`):
- New `TableColumn { name, user_type }` for per-table column
  metadata.
- `SchemaCache.table_columns: HashMap<String, Vec<TableColumn>>`.
- `SchemaCache::columns_for_table(name)` — case-insensitive
  lookup, mirrors the walker's case-insensitive entry-word
  resolution.

**WalkContext schema plumbing** (`src/dsl/walker/context.rs`):
- `WalkContext<'a>` gains a lifetime and a `schema: Option<&'a
  SchemaCache>`. `WalkContext::new()` keeps the schemaless
  default; `with_schema(s)` is the new schema-aware constructor.

**Parser entry point** (`src/dsl/parser.rs`):
- `parse_command_with_schema(input, schema)` is the new public
  schema-aware variant. `parse_command(input)` becomes a thin
  wrapper that delegates with `None` for back-compat.
- Internal `try_walker_route` accepts an `Option<&SchemaCache>`
  and threads it into the WalkContext.

**Node::Ident writes_table/writes_column** (`src/dsl/grammar/mod.rs`):
- Two new fields on `Node::Ident`. When `writes_table: true` and
  `source: Tables`, the walker writes the matched ident's name
  into `current_table` and resolves `current_table_columns`
  against the schema cache. When `writes_column: true` and
  `source: Columns`, the walker writes the resolved
  `TableColumn` into `current_column`.

**Walker driver DynamicSubgrammar dispatch** (`src/dsl/walker/driver.rs`):
- The `Node::DynamicSubgrammar(factory)` branch now resolves the
  factory at walk time and `Box::leak`s the result so its inner
  static-slice fields (Choice/Seq) have the lifetime the walker
  expects (per ADR-0024 §sub-grammars). The leak is bounded by
  command-shape complexity per walk; per-walk arena is a future
  optimisation.
- `walk_ident` extends to perform the schema writes when the
  flags are set.

**Typed value slot factories + dynamic sub-grammars** (`src/dsl/grammar/shared.rs`):
- `int_slot` / `real_slot` / `decimal_slot` / `bool_slot` /
  `text_slot` / `date_slot` / `datetime_slot` / `blob_slot` —
  one per `Type`. Each accepts the appropriate literal kind plus
  `null`; integer-only validator rejects `3.14` at int columns;
  decimal validator pins numeric shape.
- `slot_for_type(ty) -> Node` is the dispatcher.
- `current_column_value(ctx) -> Node` is the dynamic sub-grammar
  for `set col = …` and `where col = …` values; reads
  `current_column` and dispatches via `slot_for_type`.
- `column_value_list(ctx) -> Node` is the dynamic sub-grammar
  for `insert into T values (…)`; reads `current_table_columns`
  and unfolds a Seq of typed slots separated by commas.
- Both fall back to the schemaless `VALUE_LITERAL` choice when
  the context lacks the schema-resolved entries — keeps
  schemaless `parse_command` callers (tests, replay path)
  working.

**Data-command grammar wires the new types** (`src/dsl/grammar/data.rs`):
- `TABLE_NAME_INSERT` / `TABLE_NAME_WRITES` (new): table-name
  slots that set `writes_table: true`. Used by insert / update /
  delete to populate `current_table_columns`.
- `SET_COLUMN` / `FILTER_COLUMN` (new): column-name slots in
  `set col=…` / `where col=…` set `writes_column: true`.
- `INSERT_VALUES_LIST` becomes `DynamicSubgrammar(column_value_list)`.
- `UPDATE_ASSIGNMENT` and `WHERE_CLAUSE` use
  `PER_COLUMN_VALUE = DynamicSubgrammar(current_column_value)`.

**Runtime plumbs schema-with-types** (`src/runtime.rs`):
- `refresh_schema_cache` calls `describe_table` for each table
  and populates `SchemaCache::table_columns` with
  `TableColumn { name, user_type }` entries. Best-effort: a
  `describe_table` miss leaves that table unpopulated and the
  walker falls back to schemaless dispatch.

**App dispatches with schema** (`src/app.rs`):
- `dispatch_dsl` routes through `parse_command_with_schema(&self
  .schema_cache, …)` so live typing/dispatch sees the typed
  slots. The replay path stays schemaless (deferred — replay
  bind-time errors still catch type mismatches).

**Catalog** (`src/friendly/strings/en-US.yaml`, `src/friendly/keys.rs`):
- New `parse.custom.bind_type_mismatch` entry with `{found}` and
  `{expected}` placeholders. Surfaced by the int_slot /
  decimal_slot validators.

Tests:
- 11 new walker-side Phase D tests cover insert / update /
  delete with schemas — typed acceptance per column, decimal
  rejection at int columns, null acceptance at any slot,
  multi-assignment per-column dispatch, schemaless fallback.
- The pre-existing `parse_command(input)` test suite (no
  schema) still passes — the fallback path is behaviour-
  preserving.
- 828 passing total, 0 failing, 1 ignored. Clippy clean.

src/dsl/walker/driver.rs

@@ -92,21 +92,44 @@ pub fn walk_node(
             role,
             validator,
             highlight_override: _,
-        } => walk_ident(source, pos, *src, role, *validator, path, per_byte),
+            writes_table,
+            writes_column,
+        } => walk_ident(
+            source,
+            pos,
+            *src,
+            role,
+            *validator,
+            *writes_table,
+            *writes_column,
+            ctx,
+            path,
+            per_byte,
+        ),
         Node::NumberLit { validator } => walk_number_lit(source, pos, *validator, path, per_byte),
         Node::Literal(literal) => walk_literal(source, pos, literal, path, per_byte),
         Node::StringLit => walk_string_lit(source, pos, path, per_byte),
-        Node::BlobLit | Node::DynamicSubgrammar(_) => {
-            // Phase A-D: not exercised yet. Reaching this branch
-            // means a future-phase grammar got declared without
-            // the walker support landing — surface as a hard
-            // failure so tests catch it loudly rather than
-            // silently mis-parsing.
+        Node::BlobLit => {
+            // BlobLit terminals are declared but no current grammar
+            // node uses them. Reaching this branch means a future
+            // grammar declared a BlobLit without walker support
+            // landing — surface as a hard failure so tests catch
+            // it loudly rather than silently mis-parsing.
             NodeWalkResult::Failed {
                 position: pos,
                 kind: FailureKind::Mismatch { expected: vec![] },
             }
         }
+        Node::DynamicSubgrammar(factory) => {
+            // ADR-0024 §sub-grammars: resolve the inner Node at
+            // walk time using the active `WalkContext`, then
+            // recursively walk it. `Box::leak` per-walk gives the
+            // inner static-slice fields (Choice/Seq) the lifetime
+            // they require; the leak is bounded by command-shape
+            // complexity per walk.
+            let resolved: &'static Node = Box::leak(Box::new(factory(ctx)));
+            walk_node(source, pos, resolved, ctx, path, per_byte)
+        }
         Node::Flag(name) => walk_flag(source, pos, name, path, per_byte),
         Node::Repeated {
             inner,
@@ -185,12 +208,16 @@ fn walk_punct(
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn walk_ident(
     source: &str,
     position: usize,
     src: crate::dsl::grammar::IdentSource,
     role: &'static str,
     validator: Option<crate::dsl::grammar::IdentValidator>,
+    writes_table: bool,
+    writes_column: bool,
+    ctx: &mut WalkContext,
     path: &mut MatchedPath,
     per_byte: &mut Vec<ByteClass>,
 ) -> NodeWalkResult {
@@ -209,6 +236,25 @@ fn walk_ident(
             kind: FailureKind::Validation(err),
         };
     }
+    // ADR-0024 §Phase D: schema-aware writes. When the ident is
+    // a Tables source with `writes_table`, resolve the matched
+    // name against the schema cache and populate current_table /
+    // current_table_columns so subsequent dynamic sub-grammars
+    // can read them. `writes_column` resolves against the
+    // already-populated `current_table_columns`.
+    if writes_table && matches!(src, crate::dsl::grammar::IdentSource::Tables) {
+        ctx.current_table = Some(text.clone());
+        ctx.current_table_columns = ctx
+            .schema
+            .and_then(|s| s.columns_for_table(&text).map(<[_]>::to_vec));
+    }
+    if writes_column && matches!(src, crate::dsl::grammar::IdentSource::Columns) {
+        ctx.current_column = ctx.current_table_columns.as_ref().and_then(|cols| {
+            cols.iter()
+                .find(|c| c.name.eq_ignore_ascii_case(&text))
+                .cloned()
+        });
+    }
     path.push(MatchedItem {
         kind: MatchedKind::Ident { role },
         text,