refactor: replace hand-written code with standard library calls

[OmarAlJarrah]

Summary

Go 1.27's standard library now covers a good share of the small loops and helpers this repo wrote by hand. This replaces them, so there is less code to maintain. One output ordering changes, described below; no other behaviour change is intended. Each commit is one kind of replacement:

• the rewrites go fix and the modernize analyzer propose, including reflect.TypeAssert, with the names they produced tidied by hand
• sort.* to slices.Sort* (all but one keep their semantics, see below), and hand-written clone and key-collecting loops to slices / maps helpers
• small local helpers the standard library already provides, for example defs.parentPointer is jsontext.Pointer.Parent
• ast.Inspect callbacks that never prune to ast.Preorder, and NumField / MapRange loops in tests to Fields / Seq2 (reflect loops in production code stay indexed, see below)
• "does any element match" loops to slices.ContainsFunc / IndexFunc
• index-then-slice splits to strings.Cut, append-onto-nil copies to slices.Clone, and an unchecked reflect assertion to a comma-ok reflect.TypeAssert
• test helpers that list a package's non-test source files use go/build.ImportDir instead of filtering os.ReadDir
• locals that exist only so a field or return can take their address use new(value): constants and literals of constants rewritten mechanically, plus five computed values whose initializer is a pure read that nothing between it and its use can change
• errors.AsType where a typed local was declared only for errors.As, strings.CutLast for the LastIndex-then-slice pair, Keys() where a loop took only the key of a sequencedmap, and a range over an int where a counted loop only counts
• intrange, modernize, usestdlibvars and usetesting are enabled in .golangci.yml, since nothing in the gate ran go fix or the modernize analyzers. They hold the forms the analyzers propose: counted loops, slices.Backward, SplitSeq, reflect.Type.Fields outside navigation.go, Index splits that keep both halves, LastIndex splits, errors.AsType, slices.Contains loops, any, http.Method* and the t. helpers. The rest of this list has no linter: sort.*, the clone and collect loops, ContainsFunc with a predicate, ast.Preorder, new(value), go/build, and an Index that only truncates
• TestMerger_ReconcileReportsDisagreementAndKeepsAWinner now asserts the winner its name promises; it checked only the diagnostic

The one output change

coordinatesBelow, which lists what interned beneath a coordinate in the --explain report, sorted with sort.Slice. It now uses slices.SortStableFunc. Nodes that share a coordinate list in the registry's ID order, which is how nodeAtPointer reads them. The unstable sort left such ties in an order that depended on the list: insertion sort is stable up to twelve elements, and past that ties can come out in any order. On the main binary, compile testdata/conformance/openapi/allof-oneof-cooccurrence.yaml --explain /components/schemas lists the two nodes at /components/schemas/Combo/oneOf/0 as composed then anon; it now lists anon then composed. It is the only spec under testdata/ whose report differs. TestCoordinatesBelow_TiedPointersListInIDOrder pins the order, and no fixture had enough entries to do so before.

Left as they are on purpose

• cmd/morphic execute still copies args with append([]string{}, …): slices.Clone(nil) is nil, and cobra then reads os.Args[1:].
• JSON Pointer escaping stays hand-written (defs.pointerEscaper, openapitest.escape): jsontext.Pointer.AppendToken rewrites a byte that is no UTF-8 as U+FFFD, a key the library never compares. defs.pointerEscaper now says so; openapitest.escape already did.
• nodeview.InternalPointer keeps strings.Split(ref, "#"); Cut reads a second # differently from the resolver it mirrors.
• annotation/decimal.go keeps its own exponent handling, since math/big cannot build 1e2000000.
• "every element passes" loops stay loops: there is no slices.All, and a negated ContainsFunc reads worse.
• The remaining ast.Inspect calls prune subtrees with return false, which Preorder cannot do.
• The four ts.PrimRef locals in schema.go keep their form: PrimRef interns a primitive, so moving it past scalarEncoding would change the order types intern in.
• errors.As in cmd/morphic/exit.go stays: its condition also tests the match, so AsType would add a statement.
• Reflect loops in production code keep indexing and MapRange: ir.WalkValues, four irverify checks, and navigation's embedsAnswer and keyed. A range over Value.Fields, Seq, Seq2 or Type.Fields cannot be inlined, so each loop puts its body on the heap. In WalkValues that took every caller's visit closure with it, and BenchmarkValidate_Petstore went from 5669 to 9031 allocations per op; keyed paid four allocations a call where indexing pays none. TestWalkValues_StructsAndMapsCostNoAllocation and TestKeyed_CostsNoAllocation pin both, and .golangci.yml declines modernize's stditerators for navigation.go, the one file where it proposes the range.
• harness TestCheckPath_UnreadableFileIsError keeps os.MkdirTemp: a unix socket path is capped near 104 bytes, and t.TempDir spells the test name into its path. usetesting has a path-and-call exclusion whose comment says so.

Not in this PR

JSON Pointer unescaping (defs.go, load/treereads.go, navigation.go) could become jsontext.Pointer.Tokens(), which matched the hand-written form on every input tried, invalid UTF-8 included. Those reads deliberately mirror how the resolver reads a pointer, and two of them unescape one token rather than a pointer, so the change needs its own review: #827.

Test plan

• go build ./..., go vet ./... and go test ./... pass on the final tree
• go fix -diff ./... and the modernize analyzer report only keyed's loop, the range declined above; applying it with go fix ./... turns TestKeyed_CostsNoAllocation red (4 allocations)
• The overlay test helper's old and new bodies return identical maps over every compilable spec under testdata/ (130 documents, 218 entries)
• jsontext.Pointer.Parent matched defs.parentPointer on 2M random inputs
• The pinned golangci-lint release (v2.14.0, built with the repo's toolchain) reports 0 issues on the final tree with the four new linters enabled
• Planted violations show the linters reach: intrange, usestdlibvars and usetesting fire on them, modernize on strings.Index splits and interface{}
• For each rewritten production site (including NormalizeMediaType, parseDecimalBound, both reach.go copies and the overlay test helper), a planted defect turns its package's tests red, and a no-op control stays green
• The main and branch binaries print the same --explain report for every spec under testdata/ at six coordinates, except the tied pair above
• TestCoordinatesBelow_TiedPointersListInIDOrder fails when coordinatesBelow goes back to an unstable sort, and passes with a comment-only edit
• BenchmarkValidate_Petstore makes 5669 allocations per op on main and on the final tree
• TestWalkValues_StructsAndMapsCostNoAllocation fails when either walk loop ranges over Fields or Seq2 (5 against 14 and 20 allocations), also under -race, and passes with a comment-only edit
• TestKeyed_CostsNoAllocation fails on the Type.Fields range (4 allocations) and passes with a comment-only edit; without the .golangci.yml exclusion, stditerators flags keyed and nothing else
• TestMerger_ReconcileReportsDisagreementAndKeepsAWinner fails when the later declaration's type wins
• CI gate (coverage, lint)