refactor(resolver): catalog return-type resolution (ReturnType + 2 methods)

[Hessesian]

Slice 4 of the unified-resolution work — collapses inventory hotspot #4 ("function return-type — 5 variants, all Option<String> for different things"). Stacked on #191 (base refactor/resolution-catalog-s3); GitHub will retarget down the stack as each merges.

The disease

Five free functions in infer.rs all return bare Option<String> for subtly different questions (by-name vs import-aware vs container vs extension vs supertype), and consumers hand-chained them — indexer.rs::find_method_return_type_for_type even called find_extension_fn_return_type explicitly after find_method_return_type, which already probes extensions first (dead step).

The catalog surface

Two intent-named, documented methods on Resolver, returning a self-documenting newtype instead of bare String:

• ReturnType(String) — the as-written result type of a call (generics + ? preserved). Deref<str> + into_inner() for the String-typed inference paths not yet migrated.
• function_return_type(fn, uri) — import-aware: reachable bind first, workspace by-name fallback (exactly what chain.rs hand-rolled).
• method_return_type(type, method, uri?) — the single composite: member/extension methods → supertype inheritance, one call.

Consumers routed off the loose free fns

• complete.rs dot-receiver inference (fn + method) — now import-aware (was the raw by-name scan).
• semantic_tokens/resolve.rs member_return_type + both call-callee function-return sites — now import-aware and gain the supertype fallback.
• indexer.rs::find_method_return_type_for_type — collapsed: dropped the dead explicit extension step and the separate supertypes call; both now live inside method_return_type.

Safety

Behavior-preserving for unambiguous names (the reachable arm falls back to the old by-name lookup). For same-named-cross-package functions, the routed sites now pick the in-scope definition — the same correctness shape as the symbol-kind slice (#191). +2 catalog tests proving the by-name fallback arm and the supertype-folding arm.

cargo test --bin kmp-lsp: 1421 passed; clippy + fmt clean.

🤖 Generated with Claude Code

[Copilot]

Pull request overview

This PR continues the unified-resolution refactor by centralizing Kotlin function/method return-type lookup behind an intent-named Resolver catalog API, replacing several “loose” Option<String> free-function call sites with import-aware catalog methods and a self-documenting ReturnType newtype.

Changes:

• Introduces ReturnType(String) plus two catalog methods on Resolver: function_return_type(fn, from_uri) and method_return_type(type, method, from_uri?).
• Routes semantic-token and completion return-type inference through the catalog (import-aware + supertype folding), removing redundant/duplicated lookup steps.
• Adds two regression tests covering the catalog’s by-name fallback arm and the supertype-inheritance arm.

Reviewed changes

Copilot reviewed 6 out of 6 changed files in this pull request and generated no comments.

Show a summary per file

File	Description
src/semantic_tokens/resolve.rs	Switches call/member return-type inference to Resolver::{function_return_type, method_return_type} for scope-aware resolution.
src/resolver/mod.rs	Re-exports ReturnType alongside Resolver for crate-wide use.
src/resolver/infer_tests.rs	Adds catalog-focused tests for by-name fallback and supertype folding behavior.
src/resolver/complete.rs	Updates dot-receiver type inference to use the new catalog return-type methods.
src/resolver/api.rs	Defines ReturnType and extends the Resolver catalog with function/method return-type entry points.
src/indexer.rs	Collapses method return-type resolution to the single catalog composite (removing dead redundant steps).