Phase 12: Shared SuperSlab Pool implementation (WIP - runtime crash)

## Summary
Implemented Phase 12 Shared SuperSlab Pool (mimalloc-style) to address
SuperSlab allocation churn (877 SuperSlabs → 100-200 target).

## Implementation (ChatGPT + Claude)
1. **Metadata changes** (superslab_types.h):
   - Added class_idx to TinySlabMeta (per-slab dynamic class)
   - Removed size_class from SuperSlab (no longer per-SuperSlab)
   - Changed owner_tid (16-bit) → owner_tid_low (8-bit)

2. **Shared Pool** (hakmem_shared_pool.{h,c}):
   - Global pool shared by all size classes
   - shared_pool_acquire_slab() - Get free slab for class_idx
   - shared_pool_release_slab() - Return slab when empty
   - Per-class hints for fast path optimization

3. **Integration** (23 files modified):
   - Updated all ss->size_class → meta->class_idx
   - Updated all meta->owner_tid → meta->owner_tid_low
   - superslab_refill() now uses shared pool
   - Free path releases empty slabs back to pool

4. **Build system** (Makefile):
   - Added hakmem_shared_pool.o to OBJS_BASE and TINY_BENCH_OBJS_BASE

## Status: ⚠️ Build OK, Runtime CRASH

**Build**: ✅ SUCCESS
- All 23 files compile without errors
- Only warnings: superslab_allocate type mismatch (legacy code)

**Runtime**: ❌ SEGFAULT
- Crash location: sll_refill_small_from_ss()
- Exit code: 139 (SIGSEGV)
- Test case: ./bench_random_mixed_hakmem 1000 256 42

## Known Issues
1. **SEGFAULT in refill path** - Likely shared_pool_acquire_slab() issue
2. **Legacy superslab_allocate()** still exists (type mismatch warning)
3. **Remaining TODOs** from design doc:
   - SuperSlab physical layout integration
   - slab_handle.h cleanup
   - Remove old per-class head implementation

## Next Steps
1. Debug SEGFAULT (gdb backtrace shows sll_refill_small_from_ss)
2. Fix shared_pool_acquire_slab() or superslab_init_slab()
3. Basic functionality test (1K → 100K iterations)
4. Measure SuperSlab count reduction (877 → 100-200)
5. Performance benchmark (+650-860% expected)

## Files Changed (25 files)
core/box/free_local_box.c
core/box/free_remote_box.c
core/box/front_gate_classifier.c
core/hakmem_super_registry.c
core/hakmem_tiny.c
core/hakmem_tiny_bg_spill.c
core/hakmem_tiny_free.inc
core/hakmem_tiny_lifecycle.inc
core/hakmem_tiny_magazine.c
core/hakmem_tiny_query.c
core/hakmem_tiny_refill.inc.h
core/hakmem_tiny_superslab.c
core/hakmem_tiny_superslab.h
core/hakmem_tiny_tls_ops.h
core/slab_handle.h
core/superslab/superslab_inline.h
core/superslab/superslab_types.h
core/tiny_debug.h
core/tiny_free_fast.inc.h
core/tiny_free_magazine.inc.h
core/tiny_remote.c
core/tiny_superslab_alloc.inc.h
core/tiny_superslab_free.inc.h
Makefile

## New Files (3 files)
PHASE12_SHARED_SUPERSLAB_POOL_DESIGN.md
core/hakmem_shared_pool.c
core/hakmem_shared_pool.h

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: ChatGPT <chatgpt@openai.com>

core/hakmem_tiny_lifecycle.inc

@@ -12,6 +12,18 @@
 // Cold/maintenance path - not performance critical.
 #include "tiny_tls_guard.h"
 
+// Phase 12: Helper to derive a representative class index for a SuperSlab
+// from per-slab metadata (all slabs are empty when used in trim).
+static inline int superslab_any_class_idx(SuperSlab* ss) {
+    if (!ss) return -1;
+    int cap = ss_slabs_capacity(ss);
+    for (int s = 0; s < cap; s++) {
+        uint8_t cls = ss->slabs[s].class_idx;
+        if (cls < TINY_NUM_CLASSES) return (int)cls;
+    }
+    return -1;
+}
+
 void hak_tiny_trim(void) {
     static _Atomic int g_trim_call_count = 0;
     int call_count = atomic_fetch_add_explicit(&g_trim_call_count, 1, memory_order_relaxed);
@@ -94,11 +106,12 @@ void hak_tiny_trim(void) {
         static _Atomic int g_debug_ss_scan = 0;
         int scan_count = atomic_fetch_add_explicit(&g_debug_ss_scan, 1, memory_order_relaxed);
         if (scan_count < 20) {  // First 20 SS scans
+            int log_cls = superslab_any_class_idx(ss);
             fprintf(stderr, "[DEBUG trim scan] ss=%p class=%d active=%u\n",
-                    (void*)ss, ss->size_class, active);
+                    (void*)ss, log_cls, active);
         }
         if (active != 0) continue;
-        int k = ss->size_class;
+        int k = superslab_any_class_idx(ss);
         if (k < 0 || k >= TINY_NUM_CLASSES) continue;
         // Do not free if current thread still caches this SS in TLS
         if (g_tls_slabs[k].ss == ss) continue;