Go: fold a package's type into one node when its methods span files (#3399) - #3400

Fixes #3399.

A Go type whose methods live in other files of the same package became several nodes, one per
file, each owning only the methods declared there — and the declaring file's node owning none of
them. extract_go mints the receiver's type in every file that declares a method on it, keyed
_make_id(pkg_scope, receiver_type), so those nodes share one id and differ only in
source_file; _disambiguate_colliding_node_ids reads that as a collision between distinct
entities and salts each one with its own path.

Change

One pass, _merge_go_package_types, run immediately after _merge_decl_def_classes and for the
same reason: before disambiguation, so it sees one source_file per id and leaves it alone. The
colliding nodes already share an id, so every edge already points at the survivor — only the
redundant duplicates are dropped, no edge moves.

The declaring file wins, identified as the only file with a contains edge to the type. When the
declaration lives outside the corpus the whole group is method-only; one node is still the
answer, so it folds on the lowest path.

Guards against a false merge

• One directory. The id folds in only the directory's name, so a/svc and b/svc collide
  on id while being different packages. Those stay split, as today.
• _test.go stops the fold. Its package clause may be the separate external svc_test
  package declaring a type of the same name. extract_go derives pkg_scope from the directory
  and never parses the package clause, so same-directory is not evidence of same package there.
• Bare type labels only. A Go type name holds neither . nor (, while every other label
  the extractor mints does (Run(), .Close(), the file node's a.go), so a package whose
  helper function and a method share a name is untouched.

Verification

Before, on the three-file package from the issue: three Server nodes, .Close() on the b.go
one and .Save() on the c.go one. After: one svc_server sourced at a.go owning both, with
the parameter_type reference from Run() pointing at it.

tests/test_go_package_type_fold.py — 6 tests: methods across files fold onto one owner; a
reference reaches the node that owns the methods; the declaring file survives a lower-sorting
method file; and the three guards above. The three positive tests fail on v8 and pass here;
the guard tests pass both ways, pinning the no-regression half.

Full suite: 5315 passed, 93 skipped, ruff check graphify tests clean. The only failures in this
environment are the pre-existing tests/test_ollama_retry_cap.py ones (no openai module
installed), which fail identically on plain v8.

Relation to #3395

Independent of it and based on v8. The Go member-call resolver added there needs exactly one
declaration of the receiver's type, so on a multi-file package it currently bails; this fold is
what lets it fire. Neither PR needs the other to land first.