Walk every fn body and const initializer, assign a per-body LocalId to each
binder (let / params / pattern / match-arm / lambda / for / catch), and
resolve every value-position reference against a scope-frame stack. Implements
the locked shadowing rule (docs/impl/resolution/N3-local-scope-resolution.md):
lexically-closest-wins with a silent nested shadow; a same-scope duplicate
binder is E0305; an unresolved single-segment reference is E0301. Qualified
paths defer to N4.

All SyntaxKind matching for body walking lives in the new ck_syntax body
projection (bodies.rs: classify_expr/classify_pat + typed wrappers), because
ck_resolve does not depend on ck_lex and so cannot name a SyntaxKind — the
resolver matches only typed Expr/Pat enums. Span gains derived Ord so per-
reference resolutions key a BTreeMap.

N3 landed ahead of the module loader: its block-scope mechanics resolve
against the single-module symbol table N1 produces, and the loader's merged
.ckh/.ck scope later enriches the module-scope fallback without changing them.
Deferred (resolve to nothing today): item scope, stdlib/primitive scope,
qualified paths, cons-pattern heads / bare-variant disambiguation.

- ck_syntax/bodies.rs: Expr/Pat classification + accessors over the CST
- ck_resolve/bodies.rs: resolve_module_bodies + scope stack + 9 unit tests
- ck_cktest: pipeline runs N3 per module after the collect pass
- tests/resolve: 4 goldens (clean body, silent shadow, E0301, E0305);
  6 existing parser/lex fixtures re-blessed (real E0301s for undefined refs)
- docs: register E0301/E0305; mark N3 landed (#32) across the slice index

@@ -0,0 +66,4 @@
+
+    /// Whether the graph holds no modules.
+    #[must_use]
+    pub fn is_empty(&self) -> bool {

@@ -0,0 +353,4 @@
+    }
+
+    #[test]
+    fn duplicate_module_name_across_two_impls_fires_e0602_naming_both() {

@@ -0,0 +354,4 @@
+        let (caller_tree, caller_src) = (&trees[last], files[last].1);
+        let (caller_name, _) = crate::module_name(caller_tree, caller_src, &mut interner);
+        let caller = linked.modules.module(caller_name).expect("caller module");
+        let scope = linked.modules.scope(caller).expect("caller scope");