fix: stop WAL recovery from advancing MANIFEST or using CURRENT (C2+C3)

Phase 1 default state had two data-loss paths in WAL recovery.

C2: resolveRecoverySegmentID fell back to CURRENT when MANIFEST=0.
    Since segment_manager writes CURRENT on every segment create/rotate,
    the first recovery in Phase 1 (MANIFEST always 0 without flush) would
    start from the active segment, skipping earlier unflushed segments.

C3: Recover called manifest.Save after every recovery, advancing
    recoverySegmentID past segments that were still the only durable copy
    of their data (no SSTable flush yet). Next restart would filter those
    segments out and permanently lose the data.

Per design §3.2 line 280, recovery must not update MANIFEST; per line
604-06, CURRENT must not be used as recovery start. Both fixes are
required together — fixing C3 alone leaves C2's data-loss window open.

Changes:
- wal/recover.go: remove manifest.Save calls on both success and
  tail-repair paths; remove CURRENT fallback in resolveRecoverySegmentID.
  RecoveryResult.NextSegmentID is now in-memory only (consumed by DB.Open
  to seed the new WalWriter, but never persisted to MANIFEST).
- wal/recover_test.go: rewrite TestRecoverUpdatesManifest as
  TestRecoverDoesNotUpdateManifest; add TestRecoverPreservesExistingManifest,
  TestRecoverIdempotentClean, TestRecoverIdempotentAfterTruncation,
  TestRecoverIgnoresCurrentFallback.
- db_test.go: add TestOpenThreeTimesKeepsData (three opens to catch C3's
  second-restart data loss; single-segment to avoid unrelated C8 bug
  where segment_manager passes byte offset as startSequence).

Verified: each new test fails on pre-fix code and passes after the fix.
Full suite green including -race.

Audit context: docs/audit-3.2.md (with Oracle revisions from bg_ef425776
and bg_2e86d33b; C8 added). Plan: .omo/plans/fix-c2-c3-wal-recovery.md
(Momus + Oracle reviewed v1.2).

wal/recover.go

@@ -24,7 +24,7 @@ func Recover(dir string, replayer BatchReplayer) (*RecoveryResult, error) {
 		return nil, fmt.Errorf("wal: recover: replayer is nil")
 	}
 
-	// Step 1: Determine recovery segment ID from MANIFEST or CURRENT.
+	// Step 1: Determine recovery segment ID from MANIFEST.
 	recoverySegmentID, err := resolveRecoverySegmentID(dir)
 	if err != nil {
 		return nil, fmt.Errorf("wal: recover: resolve segment id: %w", err)
@@ -73,10 +73,10 @@ func Recover(dir string, replayer BatchReplayer) (*RecoveryResult, error) {
 		// the replayer interface doesn't expose a count.
 		result.ReplayedEntries = 0 // caller can inspect replayer directly
 
-		// Update MANIFEST with new recovery state.
-		if saveErr := manifest.Save(dir, result.NextSegmentID); saveErr != nil {
-			return nil, fmt.Errorf("wal: recover: save manifest after truncation: %w", saveErr)
-		}
+		// Per design §3.2 line 280, recovery repair must NOT update MANIFEST.
+		// The truncated WAL state is persisted via ftruncate (see C5 for the
+		// remaining fsync gaps). MANIFEST can only advance via checkpoint
+		// (MemTable flush) in future phases.
 
 		return result, nil
 	}
@@ -96,31 +96,22 @@ func Recover(dir string, replayer BatchReplayer) (*RecoveryResult, error) {
 		result.NextSegmentID = segments[len(segments)-1].SegmentID + 1
 	}
 
-	// Update MANIFEST with new recovery state.
-	if saveErr := manifest.Save(dir, result.NextSegmentID); saveErr != nil {
-		return nil, fmt.Errorf("wal: recover: save manifest: %w", saveErr)
-	}
+	// Per design §3.2 line 280, recovery must NOT update MANIFEST.
+	// RecoveryResult.NextSegmentID is in-memory only, consumed by DB.Open to
+	// seed the new WalWriter. MANIFEST stays at its pre-recovery value.
 
 	return result, nil
 }
 
-// resolveRecoverySegmentID determines the starting segment ID for recovery.
-// It tries MANIFEST first, then falls back to CURRENT, then defaults to 0.
+// resolveRecoverySegmentID returns the recovery start segment ID from MANIFEST.
+// MANIFEST is the only authoritative source of recovery start per design §3.2
+// line 600-06. CURRENT is a write-side hint and must NOT be used here.
 func resolveRecoverySegmentID(dir string) (uint64, error) {
 	mf, err := manifest.Load(dir)
 	if err != nil {
 		return 0, fmt.Errorf("load manifest: %w", err)
 	}
-	if mf.RecoverySegmentID > 0 {
-		return mf.RecoverySegmentID, nil
-	}
-
-	// MANIFEST had 0 (fresh DB or not yet written). Try CURRENT.
-	if segID, ok := manifest.ReadCurrent(dir); ok {
-		return segID, nil
-	}
-
-	return 0, nil
+	return mf.RecoverySegmentID, nil
 }
 
 // truncateSegment truncates the file at filePath to validOffset bytes,