refactor: walk a subtree in steps, with its termination rules in one place

[ilyam8]

Summary

Restructures the walk behind Walk, WalkAll, BulkWalk and BulkWalkAll. No behavior or exported API change.

walk was one labeled loop whose break and continue carried the decisions, with one case per error status and the subtree, exception and increasing rules interleaved in one loop body.

• The walk API moves from gosnmp.go into walk.go unchanged.
• walk is the loop: it sends the walk's request, has visit judge the answer, and acts on an explicit walkStep (ask for the objects after the answer's last name, get the root as a leaf, or end).
• walker.visit holds the rules for an answer in order: an empty answer, the error statuses (one range, tooBig to inconsistentName, logged by their generated names), exception values, the subtree, the increasing check, walkFn. walker.outside decides at a value outside the subtree (the leaf fallback, the root itself, the end); walkRoot gives the default root and the leading dot; inSubtree replaces strings.HasPrefix(name, root+".") without building the prefix for every value.
• MaxRepetitions and AppOpts are still read once per walk. walkFn stays a parameter: as a field of walker it escaped with the client and moved WalkAll's closure and results to the heap.
• The walk's log lines are guarded by Logger.enabled(). Two dead conditions are gone: the NoSuchInstance check of the root branch (the exception check returns first) and the request-type condition of the AppOpts c check (the walk runs only GetNext and GetBulk).

Each known walk bug has one known-bug comment where it happens, including one found in review: after the leaf fallback the walk keeps sending Gets.

The test commits pin what mutation probes and two reviews found unobserved, each passing on the previous walk: a sibling arc that shares the root's text (gosnmp/gosnmp#78, #93), walkFn changing MaxRepetitions or AppOpts mid-walk, a first answer echoing the root, the leaf fallback's Get answered inside the subtree, AppOpts{"c": nil}, and an empty answer with an unnamed error status. BenchmarkWalk runs WalkAll and BulkWalkAll over a 100-row column. The engine test harness now fails a scenario whose transcript passes 5000 lines, so a change that makes the engine loop fails in milliseconds instead of growing memory until the test timeout.

Testing

• go test ./... on darwin/arm64 and GOARCH=386 (386 at the restructuring commit; the later commits change tests and comments); -race; the FIPS 140-only tests; golangci-lint v2.14.0 (incl. end2end): 0 issues; GOOS=windows go vet.
• Goldens unchanged by the refactor commits. Logger output unchanged: the engine suites rerun with a recording Logger (method, format, arguments) on the old and new walk give the same calls (918 in the walk suite, all 18 status names).
• Mutation probes on the new code (50, plus 8 from review): all caught except the unreachable request-type default and 4 that change only the Logger call (caught by the Logger comparison).
• An independent equivalence review ran the old and new walk side by side: every pinned scenario with and without a Logger, 1.2M random scenarios (MIBs, roots, answers with every error status, exception values, siblings, the root, equal and decreasing names, dropped answers, v1 and v2c), and a matrix of walkFn, hook and Logger actions at every call point. No difference.
• Interleaved A/B against the previous walk: time within noise; allocs/op WalkAll 2432 -> 2229 and BulkWalkAll 400 -> 295 (the guarded per-answer log line and the per-value prefix); BenchmarkGet identical.