iter prep.2-term-new-construct (DONE 4/4): Term::New AST + Form-A surface + checker + drift — closes #32

Second iteration of the kernel-extension-mechanics milestone. Ships
the `new` Form-A keyword + `Term::New { type_name, args: Vec<NewArg> }`
AST variant + `NewArg::Type|Value` enum end-to-end through schema /
surface / checker, with two new diagnostics
(`NewTypeNotConstructible`, `NewArgKindMismatch`), a new arm in
prep.1's workspace-wide normalisation pre-pass `qualify_workspace_term`
that rewrites bare `Term::New.type_name` to qualified form
(symmetric to the existing `Term::Ctor` arm), and the data-model.md
+ form_a.md anchor additions. Codegen out of scope per spec; codegen
sites get `CodegenError::Internal` arms naming the raw-buf milestone
as the carrier.

Verification:

- `cargo test --workspace`: 654 tests passing, 0 failed.
- 3 new in-source checker tests pin the elaboration paths:
  `new_resolves_via_type_scope` (the spec's worked Counter example
  checks cleanly), `new_type_not_constructible` (missing `new` def
  in home module fires the new diagnostic), `new_arg_kind_mismatch_value_where_type`
  (kind-mismatch detection).
- 2 new schema-drift pins (`term_new_round_trips`,
  `term_new_type_arg_round_trips`) ratify the JSON byte shape:
  `{"t": "new", "type": "<TypeName>", "args": [{"kind": "type"|"value",
  "value": ...}]}`.
- 1 new surface round-trip pin exercises mixed-kind args through
  Form-A → JSON → Form-A.
- 44+ exhaustive Term-match sites across 24 files extended with
  `Term::New` arms — workspace-wide cargo build clean.

Concerns documented inline:

- `crates/ailang-core/tests/schema_coverage.rs` deliberately does
  NOT register `VariantTag::TermNew` in the `EXPECTED_VARIANTS`
  set. The coverage test asserts every declared variant is
  observed in the .ail fixture corpus; no .ail fixture in the
  current tree emits `"t": "new"` (codegen-runnable Term::New
  programs require the raw-buf milestone's plugin registry).
  Registering would fail the coverage check. The `visit_term` arm
  IS extended (compile-forced); only the enum registration is
  deferred. Inline rationale in the source. Future milestone that
  ships a Term::New fixture extends both sides.
- `crates/ailang-surface/src/print.rs` `write_term` Term::New arm
  was added in Task 1 (not Task 2 as planned), because without it
  ailang-core's tests fail to compile (the surface crate is in
  the dependency graph of ailang-core's test binaries). Task 2's
  round-trip pin verified the arm's correctness.
- Task 3 (synth elaboration) needed one implementer re-loop: the
  first attempt over-qualified within-module type-references via
  `qualify_local_types` on `new`'s signature when the home module
  was the calling module itself. Fixed by skipping qualification
  when `home_module == env.current_module`.

Architectural composition with prep.1: `Term::New` joins
`Term::Ctor` as a `type_name`-bearing site that goes through
`qualify_workspace_term`'s bare→qualified rewrite before the
checker sees it. The checker's `synth` arm for `Term::New`
therefore receives an already-qualified `type_name` (or a local
bare name for same-module construction).

Milestone status: kernel-extension-mechanics (Gitea #6) advances
2/3 iters. Next: prep.3 (kernel-tier modules + param-in), issue #33.

design/contracts/0002-data-model.md

@@ -176,6 +176,32 @@ narrative — defaults, superclasses, diagnostics — lives in
 // enclosing loop (enforced at typecheck, `recur-not-in-tail-position`).
 { "t": "recur",
   "args": [ Term, ... ] }
+
+// new: functional construction. Resolves `type` via type-scoped
+// lookup to its home module, then calls the home module's `new`
+// def with the supplied args. Each arg is a `NewArg` (see below).
+// Type-args (kind = "type") instantiate the `new` def's outer
+// `Forall` vars in declaration order; Value-args (kind = "value")
+// are checked against the (substituted) param types. Strictly
+// additive (no `skip_serializing_if`; pre-existing fixtures hash
+// bit-identically — none carry the tag). See prep.2 of the
+// kernel-extension-mechanics milestone.
+{ "t": "new",
+  "type": "<TypeName>",
+  "args": [ NewArg, ... ] }
+```
+
+**`NewArg`** (one positional arg to a `(new T args...)` call):
+
+```jsonc
+// Type-positional arg: instantiates one of `new`'s outer Forall
+// vars. The inner `value` carries a full `Type` JSON object.
+{ "kind": "type",  "value": Type }
+
+// Value-positional arg: a `Term` checked against the corresponding
+// substituted param type of `new`. The inner `value` carries a
+// full `Term` JSON object.
+{ "kind": "value", "value": Term }
 ```
 
 In the MVP, `do` is only a direct call to a built-in effect op (no