Fix data race on ChunkingStats in IndexFromFile

[folbricht]

Problem

go test -race on TestParallelChunking reliably reports a data race in IndexFromFile (make.go). It is a pre-existing latent bug in production code — the recently merged deprecation PR #340 only shifted goroutine timing enough to make it observable.

• stats := ChunkingStats{} is a local in the main goroutine; its address is shared with every worker via pChunker.stats = &stats.
• Worker goroutines call c.stats.incProduced() → atomic.AddUint64(&s.ChunksProduced, 1).
• stop() is signal-only (once.Do(func(){ close(done) })); there is no join/WaitGroup anywhere. The consumer loop breaks early when a worker reports eof, leaving later workers' goroutines still running.
• The main goroutine then returns stats by value — a non-atomic full-struct read concurrent with the still-running workers' atomic increments. That is the race the detector flags.

Beyond the race, the by-value snapshot was also non-deterministic: abandoned workers keep incrementing after the function returns, so ChunksProduced was whatever happened to be counted at that instant.

Fix

make.go only:

• Track the worker goroutines with a sync.WaitGroup, spawned via the Go 1.25 (*sync.WaitGroup).Go helper (does Add(1)/Done() automatically).
• On the post-spawn exit path, route both the mid-loop error case and the normal case through a single tail that cancel()s the context, stop()s every worker, and wg.Wait()s for all goroutines to fully exit before stats is copied into the return.
  • The wait must be inline before return — a deferred cleanup runs after the return value is already copied, so it cannot fix this.
  • Because the wait runs before the deferred per-worker f.Close() calls, it also closes a latent read-from-closed-file hazard for abandoned stragglers.
  • defer cancel() / defer w.stop() are kept as an idempotent panic safety net.
• Pre-spawn early returns are unchanged (no goroutines exist yet). No signature change; cmd/desync/make.go (the only consumer that reads the returned stats) and all _-discarding callers are unaffected.

Scope: only the stats race (the one -race flags). The c.err/c.eof cross-goroutine reads are already safe via the close(c.results) happens-before edge; the c.next list-collapse mutation is a separate theoretical concern intentionally left out to keep this minimal.

Test

Added TestIndexFromFileStats: drives the early-EOF/straggler path with null-heavy inputs across worker counts 2–8 and asserts the now race-free, deterministic invariants — ChunksAccepted == len(index.Chunks), ChunksProduced >= ChunksAccepted, ChunksProduced > 0. TestParallelChunking is kept as-is as the chunk-equivalence guard.

Verification

• go test -race -count=5 -run 'TestParallelChunking|TestIndexFromFileStats' . — no WARNING: DATA RACE (162s; previously reproduced within a few iterations).
• go test -run TestIndexFromFileStats -count=20 . — deterministic, green.
• Full go test -race . and go test ./cmd/desync — green.
• go vet ./... clean, go build ./cmd/desync clean.