fix(python): suppress bare calls shadowed by an enclosing parameter

[DeusData]

Distilled from #1386 with Co-authored-by: credit to @Joseph-MingEn, who identified this defect class. The mechanism differs from theirs — see below.

The gap

After #1903 landed Python member-call suppression, this still resolves wrongly:

def _run_with_heavy_slot(run):
    return run()          # suffix_matches onto SatoriLive.run

#1903 structurally cannot catch it — there is no receiver, so its guard never fires. #1647's cross-language suffix guard only fires when caller and target languages differ, and both are Python here. So the class survives everything currently on main.

Keyed on local binding, not on a name list

#1386 keyed this on {get, run, execute}. That is a claim about spellings, not about whether the resolver knew anything — and it would age invisibly: nothing fails when the generic-name distribution shifts, the graph just quietly loses different edges. It is also open-ended (why not start, send, handle, process?) and corpus-dependent.

This keys on the fact that decides the question: the callee identifier is bound as a parameter of an enclosing function, so it shadows any project function and short-name resolution is fabricated by construction. No list, decidable outright, and it covers handler(), callback(), fn() and every Callable-parameter shape.

Parameters only, deliberately. A parameter is in scope for the entire body regardless of position, and Python forbids global on a parameter (SyntaxError: name is parameter and global), so no flow analysis is needed. Local assignments are flow- and binding-form-sensitive across for, with…as, except…as, :=, unpacking, nested def/class, import, plus global/nonlocal — a partial version would be incomplete invisibly, which is the failure mode the name list was rejected for. That wants a real scope analyser and its own evidence.

Enclosing scopes are walked to any depth, so def outer(run): def inner(): return run() — a common decorator/callback shape — is covered. The one knowingly over-flagged shape (global run in a nested function whose outer scope has a run parameter) is documented in the helper rather than left silent.

A new field rather than overloading is_method

callee_is_locally_bound is a distinct field on CBMCall. is_method means "member call with unresolved receiver" and is read by the pxc synthetic-carrier dedup key (pass_lsp_cross.c:801/:815); overloading it for bare calls would corrupt that key and make the field's documented contract untrue.

One drop-list, shared

The weak-strategy list (suffix_match / unique_name / field_type_hint / fuzzy) is now a single weak_short_name_strategy() used by both the member guard and this one. Two copies would have let the guards silently disagree about what "weak" means. weak_call_guards_share_one_drop_list pins that agreement across 15 strategies — and it fired correctly during revert-check.

Python-gated, wired at both pass_calls.c and pass_parallel.c with textually identical gates. ArkTS preserved in both member gates.

Evidence — three revert-check rounds, each isolating one claim

round	break	result
A	disable the pass_parallel.c gate only	exactly 1 failure — the ≥50-file test; the sequential test still passed. Proves the parallel test genuinely exercises pass_parallel.c rather than falling back to the sequential path
B	under-suppress (flag + guard)	exactly 5 failures, all this change's — extraction flag, both registry drops, both pipeline negatives
C	over-suppress (guard ignores the binding)	exactly 3 failures — the registry keep-assertion and both pipeline positive controls

Round C is the one that matters. It proves the positive controls are not vacuous: uses_free_function → compute_widget_total is a cross-file bare call with no import, so it resolves by a weak strategy this guard can drop — and an over-suppressing guard does drop it. #1386's positive asserted a same_module edge that no guard touches for any input, so it would have passed even if the change dropped every other Python edge. Both pipeline tests also carry ASSERT_GTE(CALLS, 1) anti-vacuity.

The extraction test pins all 7 parameter binding forms (bare, typed, default, keyword-only, *args, **kwargs, lambda, closure) plus 3 negatives (unbound, imported, nested def), each asserted to appear exactly once.

Verification

pipeline registry parallel extraction complexity lsp_resolution_probe → 805 passed, 0 failed. Built in a fresh worktree with no prior build/, so no stale-binary exposure. All 6 new tests confirmed by name in output, and RUN_TESTs verified inside SUITE(pipeline) rather than the pipeline_semantic_manifest_repro decoy that has swallowed tests before.

Cost is O(depth × params) per bare call — never corpus-coupled, so no complexity-guard interaction. CBMCall is not serialized, so no cache or index-format bump.