refactor(checker): reshape Checker trait (default predicates, is_primitive(&Node), narrow bounds)

[dekobon]

Summary

The Checker trait (src/checker.rs:168-231) is a ~13-method mega-trait
with no default bodies for the trivial predicates, making "add a language"
a copy-paste ritual and embedding signature inconsistencies. 2.0 is the
natural window to reshape it (it is #[doc(hidden)] and already slated for
reconsideration per STABILITY.md). Three related cleanups:

(a) Default bodies for the "almost always false/empty" predicates

is_comment, is_useful_comment, is_func_space, is_func,
is_closure, is_call, is_non_arg, is_string, is_else_if,
is_primitive are all required (no defaults). Concretely this forces
pure-boilerplate stubs: PreprocCode (src/checker.rs:233-271) and
CcommentCode (:273-311) are almost entirely false-returning, and
BashCode::is_closure (:1407) is a forced stub. is_primitive,
is_closure, is_useful_comment, is_non_arg have an obviously-safe
false default — a new language can't be told by the compiler that false
is correct.

Fix: give those predicates -> false defaults (deletes hundreds of
stub lines). Optionally split into CommentClassifier / SpaceClassifier
/ OperandClassifier sub-traits.

(b) is_primitive(id: u16) breaks the &Node convention

src/checker.rs:178 — fn is_primitive(_id: u16) -> bool;. Every other
predicate takes &Node. The sole caller already has the &Node
(src/metrics/halstead.rs:382 does T::is_primitive(node.kind_id())).
Passing a bare u16 where the rest of the trait passes a domain type is
the "two same-typed primitives" footgun (AGENTS.md) and forecloses
primitive checks that need children/text.

Fix: fn is_primitive(_node: &Node) -> bool with default false.

(c) Narrow count_specific_ancestors from ParserTrait to Checker

src/node.rs:237 — count_specific_ancestors<T: ParserTrait> instantiates
the full 15-associated-type ParserTrait purely to call
T::Checker::is_else_if. Callers pass PythonParser etc.
(src/metrics/cognitive.rs:421, loc.rs:1014).

Fix: bound on <C: Checker> and call C::is_else_if; callers pass
PythonCode. Internal (pub(crate)), so fixable anytime, but belongs with
the trait reshape.

Why it matters for 2.x

Default bodies and the is_primitive signature change are best landed with
the #[doc(hidden)]-trait fate decision already on the 2.0 roadmap (#505).

Part of #505. Label: enhancement.

[dekobon]

Resolved in refactor(checker): give predicates false defaults (d2b781a)

All three deliverables landed; the optional sub-trait split was intentionally skipped (see below).

(a) Default bodies — done

The ten predicates (is_comment, is_useful_comment, is_func_space,
is_func, is_closure, is_call, is_non_arg, is_string,
is_else_if, is_primitive) now carry #[inline] -> false defaults.
Per-language -> false stubs were deleted — ~150 lines removed across
the 22 impls (310 lines changed in checker.rs: 110 insertions /
247 deletions overall). PreprocCode collapsed from 11 methods to 2;
CcommentCode from 11 to 3; BashCode::is_closure stub gone.

Kept deliberately: comment-bearing intentional-false overrides
(Tcl/Irules is_closure/is_non_arg, Elixir is_func/is_else_if).
These anchor language-specific rationale ("Tcl closures are ordinary
commands", "Elixir lacks an else-if chain") that has no other home —
deleting them would lose the why, against
.claude/rules/macro-comments.md. The
clarity review endorsed keeping documented intentional-false overrides
while deleting bare boilerplate.

(b) is_primitive(&Node) — done

Signature changed (u16) -> (&Node) on the default plus the 5 real
bodies (Cpp, Csharp, Typescript, Tsx, Rust). Sole caller
halstead.rs:382 is now T::is_primitive(node). Guarded by the
mutation-verified rust_aliased_primitive_type_classification and
csharp_predefined_types_keyed_by_lexeme tests — I re-confirmed the
guard by forcing CsharpCode::is_primitive to false and watching
csharp_predefined_types_keyed_by_lexeme fail (u_operators 5 vs 9).

(c) Narrow count_specific_ancestors — done

Bound changed <T: ParserTrait> → <C: Checker>, calling C::is_else_if.
All 8 call sites updated: the JS-family macros now use ::<Self> (the
$parser macro param was dropped entirely), cognitive.rs passes
PythonCode, and loc.rs passes Cpp/Java/Groovy/Csharp/GoCode.

Sub-trait split (optional) — not done

Splitting Checker into CommentClassifier / SpaceClassifier /
OperandClassifier was marked optional. With the false defaults in
place the copy-paste pain is already gone, and the split would add three
trait names + supertrait bounds across ParserTrait and every metric
generic for little further gain. Skipped to keep the change focused; can
be revisited at 2.0 alongside the doc-hidden-trait fate decision.

Stability note

Checker lives in a private module (mod checker;) and is only
pub(crate) re-exported — it is crate-internal, not even a
doc-hidden public item. So this is a pure internal refactor: no
public-API break, and serialized metric output is byte-identical
(full cargo test --workspace --all-features green, zero snapshot
drift).

Follow-up filed

#528 — is_else_if predicates still fall into 3 repeated structural
shapes (parent==ElseClause ×6, prev-sibling==Else ×4, dedicated
clause node ×6) that could be macro-consolidated like
impl_simple_is_string!. Surfaced during this work; pure reuse cleanup,
out of scope here.

Validated with simplify-rust, rust-optimize, audit-tests,
code-review (high effort, 3 angles), review (APPROVE), and
make pre-commit (Rust + Python, self-scan gate, snapshot anchors).