refactor: split sendOneRequest into the steps of a request

[ilyam8]

Summary

Splits sendOneRequest, the core of the request engine, into the steps of a request. No behavior or exported API change.

sendOneRequest used to run a request in one function: an attempt loop and a read loop, both labeled, steered by one shared err. Which failures retried and which ended the request depended on the loop a break left and on the value err held at that moment. It now reads as:

• sendOneRequest: the attempt loop; keeps the request IDs of earlier attempts and runs OnFinish on success.
• beforeRetry: OnRetry, then the request's error when no retry follows (a timeout under the context's deadline, the retries used up), else the next timeout.
• attempt: context check, deadline, request ID, encode, hooks, write, then await. Its outcome is a value: the request's result, or a retry with its reason.
• await: reads until a reply answers the request; a TCP EOF reconnects for the next attempt.
• decode: header, then for an SNMPv3 client authentication and scoped PDU, then PDU.
• answers: the empty-reply rule, Reports through a table of counters to errors, the request IDs.

The first commit moves send and sendOneRequest from marshal.go into engine.go unchanged, so the decomposition reads as a change within one file; send itself is unchanged (next step).

Each known bug of the old function keeps one site with a known-bug comment. The request IDs of earlier attempts stay in sendOneRequest's frame, so the slice stays on the stack as before.

The test commits pin behaviors mutation probes and review found unobserved; each pin passes on the old code: replies of another SNMP version than the client's, a reply to the first attempt read in the third, the dynamic type and sentinel identity of every returned error (describeEngineError), a context canceled with a cause, a context deadline equal to the attempt's, a hook that changes the privacy protocol between attempts, two TCP reconnect paths, and the reply's Logger.

Testing

• go test ./... on darwin/arm64 and GOARCH=386; -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 transcript logger on the old and new code give the same 2934 log lines.
• 110 mutation probes on engine.go: 96 caught by the suite; 12 change only logger output (11 caught by the logger comparison; the 12th drops a line reachable only over loopback TCP); 1 differs only when a hook rewrites the client's engine ID mid-request; 1 skipped (superseded by request-ID order probes, caught).
• An independent equivalence review compared the old and new function side by side over every pinned scenario, 120k random scenarios (v1/v2c/v3) and a loopback TCP matrix: no difference.
• BenchmarkSendOneRequest, interleaved A/B: B/op and allocs/op identical; time within noise in 6- and 12-round runs (a 12x12 run measured +0.7%, about 7 ns per request).