test(raft): rename cap + add Bytes() round-trip (PR #746 r2)

Round-2 review on commit 070d5e6 from claude bot:

- Issue A (gocritic builtinShadow): renamed local const `cap` to
  `spoolCap` in TestSnapshotSpool_OverrideViaEnv. `cap` is a Go
  built-in identifier and shadows trip golangci-lint's gocritic
  rule.

- Issue B (refactor coverage gap): Bytes() switched from
  io.ReadAll to make([]byte, s.size) + io.ReadFull at PR-round-1.
  TestSnapshotSpool_DefaultCapAcceptsRealisticFSM exercised Write
  at 1.5 GiB but never called Bytes() — a regression where the
  pre-allocation drifts out of sync with the on-disk size would
  not surface. Added a Bytes() call after the write loop with:
    - len(got) == target  (catches short reads / size drift)
    - first/last byte == 0xAB  (catches catastrophic corruption
      without paying the memory cost of full byte-equality on a
      1.5 GiB slice)

No semantic changes. The OOM concern from the Codex P1 reviewer
is acknowledged in the PR body and tracked as a follow-up
(streaming apply); the immediate-incident risk is bounded by
real FSM size (~1.35 GiB today), not by the new 16 GiB ceiling.

Test:
  go test -race -count=1 -short ./internal/raftengine/etcd
  -- 11.6s, all green.
  go test -race -count=1 \
    -run TestSnapshotSpool_DefaultCapAcceptsRealisticFSM \
    ./internal/raftengine/etcd
  -- 3.0s, green (1.5 GiB Write + Bytes round-trip succeeds).

Author: bootjp

internal/raftengine/etcd/snapshot_spool_test.go

@@ -45,23 +45,36 @@ func TestSnapshotSpool_DefaultCapAcceptsRealisticFSM(t *testing.T) {
 		written += int64(n)
 	}
 	require.Equal(t, target, spool.size)
+
+	// Round-trip through the materialization path (the io.ReadAll →
+	// io.ReadFull refactor) to lock down behaviour at 1.5 GiB. The
+	// returned slice MUST match s.size exactly: a short read here would
+	// indicate the pre-allocation drifted out of sync with what Write
+	// actually persisted to the spool file.
+	got, err := spool.Bytes()
+	require.NoError(t, err)
+	require.Equal(t, int(target), len(got), "Bytes() returned %d, want %d", len(got), target)
+	// Spot-check first/last bytes match the 0xAB fill; full byte-equality
+	// would double the test's memory cost without adding signal.
+	require.Equal(t, byte(0xAB), got[0])
+	require.Equal(t, byte(0xAB), got[len(got)-1])
 }
 
 // TestSnapshotSpool_OverrideViaEnv confirms the env knob actually moves the
 // cap. Tests deliberately *lower* it (cheap to write past) instead of
 // raising — the upper-bound test above already proves a generous cap works.
 func TestSnapshotSpool_OverrideViaEnv(t *testing.T) {
-	const cap = int64(4096)
-	t.Setenv(maxSnapshotPayloadBytesEnvVar, strconv.FormatInt(cap, 10))
+	const spoolCap = int64(4096)
+	t.Setenv(maxSnapshotPayloadBytesEnvVar, strconv.FormatInt(spoolCap, 10))
 
 	spool, err := newSnapshotSpool(t.TempDir())
 	require.NoError(t, err)
 	t.Cleanup(func() { _ = spool.Close() })
 
-	require.Equal(t, cap, spool.maxSize)
+	require.Equal(t, spoolCap, spool.maxSize)
 
 	// Write up to the cap — succeeds.
-	_, err = spool.Write(bytes.Repeat([]byte{0x01}, int(cap)))
+	_, err = spool.Write(bytes.Repeat([]byte{0x01}, int(spoolCap)))
 	require.NoError(t, err)
 
 	// One byte past — fails with the documented sentinel so callers can