feat(lsp): resolve cross-file base classes in the Python/TS cross-LSP

[DeusData]

Makes the Python/TypeScript cross-LSP resolve cross-file base classes, so a call to an inherited method through a typed receiver resolves via an lsp_* strategy instead of falling through to the weak textual cascade.

The gap was one line, and it was not what the code comments claimed

The base-class walk already existed in both languages — py_lookup_attribute_depth (py_lsp.c:1059) and ts_lookup_member (ts_lsp.c:1702/:1854) both iterate CBMRegisteredType.embedded_types, the same inheritance channel C/C++, Java, PHP and Rust use.

What was wrong were the names it walked. pass_lsp_cross.c:286:

dst->embedded_types = pxc_join_pipe(arena, src->base_classes);   /* RAW source spelling */

base_classes holds what the source says — "Base" — while py_register_lsp_defs / ts_register_lsp_defs feed each entry into cbm_registry_lookup_type as a qualified name. A base declared in another file therefore never matched: class Child(Base) in child.py could not see Base in base.py. Receiver unresolved → weak textual cascade → the member guard correctly kills it.

The per-file registrars do qualify bases, but with the current file's module — wrong cross-file, and they never see imported files anyway.

pass_semantic already resolves this correctly for INHERITS, via resolve_as_class. The cross-LSP simply never received it, and lsp_cross runs before semantic, so those edges do not exist yet to reuse.

The stale comment that sent everyone the wrong way

test_lsp_resolution_probe.c cited a known Python base_classes extraction bug as the blocker. That bug is fixed: extraction_inheritance is 9/9 green across Python, TypeScript and TSX, and base_classes holds clean names — "Animal", "Generic", "django.db.Model", "React.Component" — with parens, extends/implements, generic subscripts and metaclass= kwargs already stripped. The names were never dirty. They were unqualified. That comment is replaced.

The fix — one generic change, both languages

cbm_pxc_collect_all_defs now resolves each base spelling to a project QN using exactly the inputs pass_semantic uses for INHERITS: project registry, declaring module, and the file's import map. The LSP's inheritance view is therefore the same relation the graph records, so the two cannot diverge.

Scoped to Python/JS/TS/TSX. Go, JVM, C#, C++ and Rust qualify their own embedded types and keep the raw join.

Weak strategies are rejected for bases — suffix_match/unique_name/field_type_hint/fuzzy are dropped via an explicit list mirroring the member guard. A base bound by name-coincidence is the #606 failure multiplied across every inherited member, which is a far worse trade than the member-level case. Unresolved bases keep their raw spelling, so stdlib and third-party bases are untouched. In the fixtures, resolution goes through the import map, not a guess.

The probes assert the STRATEGY, not the count

In a two-file fixture a lucky short-name guess and a genuinely resolved inherited member produce the same edge count. Only the strategy separates them, so a new helper counts edges by resolution strategy:

probe	before	after	strategy
ts/S6	calls == 0 tripwire	calls >= 1 + lsp_ts asserted	lsp_ts_method, conf 0.95
python/S6b (new)	—	INHERITS >= 1 + lsp_ asserted	lsp_method, conf 0.90

Revert-check: stashing the source change and rebuilding sends all three S6b receiver shapes — annotated parameter, self in the subclass, constructor result — back to unique_name/0.75. With the change they resolve lsp_method/0.90.

python/S6 is left alone, and its flip-back note was wrong

python/S6 asserts calls == 0 and keeps doing so. Despite its name it is not an inheritance case: its def run(c) parameter is un-annotated, so no receiver type exists to inherit through, and any binding of c.describe() is a guess about a name. Its previously-documented flip-back condition — >= 1 once the cross-LSP resolves inheritance — was unattainable by construction, and that claim is corrected rather than inherited. S6b covers the real case by supplying the receiver type S6 deliberately withholds.

Verification

• macOS full suite: 7,690 passed / 0 failed / 8 skipped (140 suites), run twice on the final tree.
• lsp_resolution_probe 88 passed (was 87 — the new test confirmed by name in output, count moved).
• complexity 4/4: nodes 1.93, edges 2.07, per-file defs 2.00, shared-package leg 1.98/2.00 — against the ~4 that a files×corpus coupling produces. Cost is O(defs) hash lookups plus one import map per file; no per-call-site hierarchy walk, no registry scan, no per-file registry rebuild.
• make lint-ci clean.
• Rebased onto main after fix(pipeline): suppress weak Python member calls #1903 merged; the one conflict was in python/S6's comment, resolved by keeping fix(pipeline): suppress weak Python member calls #1903's assertion and tripwire while correcting its flip-back claim per the above.