CP HiCache L3 3.4: cold-start (restart durability) — load|clear via SGLANG_CP_L3_COLD_START

On restart the LMDB index + disk-slab blobs persist, but CpL3Store.from_config built the slot
pools all-free and the GC LRU empty -> the next spill re-hands-out a slot the durable index still
references (clobbers a live blob) and GC never reclaims the carried-over entries. Neither a clean
start nor a durable reload was actually realized.

connect() now applies a cold-start policy BEFORE the bg threads start (the write thread is the sole
pool/GC owner, so the single-threaded reconcile must precede it):
  - clear (default): wipe the persisted index + reset the pools/GC -> genuinely empty start (disk
    blobs are inert, overwritten lazily on slot reuse).
  - load: rebuild this rank's slot free-list + GC LRU from the durable disk blobs. Drive the scan
    from the rank's OWN slab file (header-only reads) so it never inspects another rank's slots even
    when ranks share a disk; a slot is LIVE iff its blob header parses AND the shared index still maps
    that content hash back to this exact slot -> occupy + seed the GC LRU with the durable last_access;
    orphan/unwritten slots stay free. Header-only (no payload CRC); reload-time verify-on-read still
    fail-softs a torn payload. The L3 durable floor now survives a process restart.

Primitives: CpL3SlotPool.rebuild_from_allocated (O(num_slots) bulk-occupy) + CpL3DiskSlab.read_header
(one aligned block, not the multi-MB slot). Env SGLANG_CP_L3_COLD_START (default "clear"), read in
_maybe_init_cp_l3 and passed to connect(). Tests: 4 cold-start e2e (load rebuilds the floor + no slot
collision after a fresh spill; GC LRU rebuilt; clear starts empty; unknown mode fails loud) + 2 unit
(rebuild_from_allocated, read_header). 23 L3 store/disk/posix tests green.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

test/registered/unit/mem_cache/test_cp_l3_disk.py

@@ -135,6 +135,25 @@ class TestSlotPool(unittest.TestCase):
         with self.assertRaises(ValueError):
             m.CpL3SlotPool(0)
 
+    def test_rebuild_from_allocated(self):
+        # cold-rebuild: occupy a subset in bulk, free list = the complement (deterministic lowest-first).
+        p = m.CpL3SlotPool(6)
+        p.rebuild_from_allocated([1, 3, 4])
+        self.assertEqual(p.num_allocated, 3)
+        self.assertEqual(p.num_free, 3)
+        self.assertEqual([p.alloc() for _ in range(3)], [0, 2, 5])  # complement, lowest-first
+        self.assertEqual(p.alloc(), -1)  # full
+        # the rebuilt-allocated slots are genuinely occupied (free() accepts them, double-alloc cannot reissue)
+        p.free(3)
+        self.assertEqual(p.alloc(), 3)
+
+    def test_rebuild_from_allocated_fail_loud(self):
+        p = m.CpL3SlotPool(4)
+        with self.assertRaises(ValueError):
+            p.rebuild_from_allocated([0, 4])  # out of range
+        with self.assertRaises(ValueError):
+            p.rebuild_from_allocated([2, 2])  # duplicate
+
 
 if __name__ == "__main__":
     unittest.main()