fix(semantics): resolve #' function designators to their local binding

[takeokunn]

references.rs returned early on a Function reader prefix, so #'g was dropped entirely:

(flet ((g () 1)) (mapcar #'g list))   ; -> zero references to g

Any rule reading BindingTable sees a live, called function as unused — and would advise deleting working code.

(function g) long-hand had the same symptom by a different path: reader_form matched the shape and returned true without ever visiting the name. Two drops, one bug.

The early return was about namespace, not about #'car

Deleting it makes (let ((g 1)) #'g) resolve to the variable g — #' on a variable designates nothing in CL, and the value layer would then propagate a variable's value into a function designator.

So the fix overrides the namespace instead of cancelling the occurrence:

let namespace = if view.reader_prefixes.contains(&ReaderPrefix::Function) {
    Namespace::Function
} else {
    namespace
};

Namespace::admits keeps a Lisp-2 honest: the variable case still misses (verified — (let ((g 1)) (mapcar #'g list)) records zero references post-change), and #'car resolves to nothing unless the file really did flet a local car, in which case it genuinely is a reference. The quasiquote check moved above the prefix check — behaviour-preserving, both returned before — so '#'g and `(a #'g) stay inert.

No shipped rule or report changes — and I verified why

corpus	inspect lint pre	post	gained	lost
SBCL (1428 files)	23309	23309	0	0
Quicklisp (623 files)	5302	5302	0	0

Byte-identical JSON, and the same for every semantic report. The brief's premise that "four shipped rules consume this table, so fixing it will change their findings" does not hold, and the reason matters: the only consumer that reads Binding::references() emits reference_count solely for propagated bindings, and blocked_reason returns NotAVariable first — so a Function binding never reaches that field.

The zero is not a dead harness. Because the old walk resolved exactly zero designators by construction, the post-change resolved count is the delta:

corpus	designator refs gained	local callables 0 → ≥1 references
SBCL	507	279
Quicklisp	94	46

325 bindings across ~2000 files stop looking unused — the same order as the 250 that motivated this. Four adjudicated in source, all reachable only through #': sb-concurrency's enc-1 under dynamic-extent, uiop's separatorp via position-if, full-eval's to-native-funs via mapcar, win32-sockets' make-definition via mapcar.

Two claims in the brief were wrong

Neither let_report nor unused_local_callable_report touches BindingTable — they use lexical_scope and callable_scope. The latter's callable_reference_target already handled #' correctly, which is why inspect unused-local-callables never had this bug.

Triage of the five other reported gaps

• loop is not a modelled binder — confirmed, and worse than reported. It is in head_has_registered_semantics, so the scope is marked transparent while binding nothing. In (let ((j 1)) (loop for j from 1 to 10 do (print j))) the outer j absorbs both the binder occurrence and the body's use — the false-positive direction, and a rename driven by this table would rewrite the loop variable. Deferred (LOOP's clause grammar is its own sub-language); a one-line mitigation is to mark loop scopes opaque.
• Template splice in operator position — REFUTED. `(,fn 1 2) resolves correctly. The cited SBCL instance (target-sxhash.lisp:410-437) fails for the next reason instead — both uses sit under #+64-bit.
• Reader conditionals inside a quasiquote — confirmed. Outside one the dispatch is marked opaque; inside one it is not, because atom_in returns on quasiquote depth before reaching is_reader_dispatch. The scope claims transparency while a live reference is hidden. Not bundled: opacity feeds BlockedReason::OpaqueScope and value propagation, so it needs its own differential. Recommended as the next change.
• declare (ignore …) — confirmed, well-scoped, deferred. Needs a new public field on Binding, which moves the semantic-report envelopes and pinned counts. The machinery exists as a template in special_names.rs.
• Cross-file specials — not a bug at this layer. BindingTable is one file's lexical context by contract, and inferring specialness from earmuffs is the trap that already killed two rules in this repo. The right home is the project layer.

A hole in the existing oracle, documented rather than papered over

The differential partition oracle cannot catch this class: its bound set is derived by filtering the live occurrences, and #' atoms were excluded from live on both sides — so the bug was, and would again be, invisible to it. That's now noted in collect_live.

Verification

cargo build --workspace, cargo test --workspace (semantics 453 passed, up from 448), cargo test --test cli (3083 passed), cargo fmt --all --check, cargo clippy --all-targets --all-features -- -D warnings — all exit 0. No golden or pinned count moved. packages/core/syntax untouched.