CRITICAL FIX: TLS 未初期化による 4T SEGV を完全解消

**問題:**
- Larson 4T で 100% SEGV (1T は 2.09M ops/s で完走)
- System/mimalloc は 4T で 33.52M ops/s 正常動作
- SS OFF + Remote OFF でも 4T で SEGV

**根本原因: (Task agent ultrathink 調査結果)**
```
CRASH: mov (%r15),%r13
R15 = 0x6261  ← ASCII "ba" (ゴミ値、未初期化TLS)
```

Worker スレッドの TLS 変数が未初期化:
- `__thread void* g_tls_sll_head[TINY_NUM_CLASSES];`  ← 初期化なし
- pthread_create() で生成されたスレッドでゼロ初期化されない
- NULL チェックが通過 (0x6261 != NULL) → dereference → SEGV

**修正内容:**
全 TLS 配列に明示的初期化子 `= {0}` を追加:

1. **core/hakmem_tiny.c:**
   - `g_tls_sll_head[TINY_NUM_CLASSES] = {0}`
   - `g_tls_sll_count[TINY_NUM_CLASSES] = {0}`
   - `g_tls_live_ss[TINY_NUM_CLASSES] = {0}`
   - `g_tls_bcur[TINY_NUM_CLASSES] = {0}`
   - `g_tls_bend[TINY_NUM_CLASSES] = {0}`

2. **core/tiny_fastcache.c:**
   - `g_tiny_fast_cache[TINY_FAST_CLASS_COUNT] = {0}`
   - `g_tiny_fast_count[TINY_FAST_CLASS_COUNT] = {0}`
   - `g_tiny_fast_free_head[TINY_FAST_CLASS_COUNT] = {0}`
   - `g_tiny_fast_free_count[TINY_FAST_CLASS_COUNT] = {0}`

3. **core/hakmem_tiny_magazine.c:**
   - `g_tls_mags[TINY_NUM_CLASSES] = {0}`

4. **core/tiny_sticky.c:**
   - `g_tls_sticky_ss[TINY_NUM_CLASSES][TINY_STICKY_RING] = {0}`
   - `g_tls_sticky_idx[TINY_NUM_CLASSES][TINY_STICKY_RING] = {0}`
   - `g_tls_sticky_pos[TINY_NUM_CLASSES] = {0}`

**効果:**
```
Before: 1T: 2.09M ✅  |  4T: SEGV 💀
After:  1T: 2.41M ✅  |  4T: 4.19M ✅  (+15% 1T, SEGV解消)
```

**テスト:**
```bash
# 1 thread: 完走
./larson_hakmem 2 8 128 1024 1 12345 1
→ Throughput = 2,407,597 ops/s ✅

# 4 threads: 完走（以前は SEGV）
./larson_hakmem 2 8 128 1024 1 12345 4
→ Throughput = 4,192,155 ops/s ✅
```

**調査協力:** Task agent (ultrathink mode) による完璧な根本原因特定

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

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

core/box/hak_alloc_api.inc.h

@@ -0,0 +1,131 @@
+// hak_alloc_api.inc.h — Box: hak_alloc_at() implementation
+#ifndef HAK_ALLOC_API_INC_H
+#define HAK_ALLOC_API_INC_H
+
+__attribute__((always_inline))
+inline void* hak_alloc_at(size_t size, hak_callsite_t site) {
+#if HAKMEM_DEBUG_TIMING
+    HKM_TIME_START(t0);
+#endif
+    if (!g_initialized) hak_init();
+
+    uintptr_t site_id = (uintptr_t)site;
+
+    if (__builtin_expect(size <= TINY_MAX_SIZE, 1)) {
+#if HAKMEM_DEBUG_TIMING
+        HKM_TIME_START(t_tiny);
+#endif
+        void* tiny_ptr = NULL;
+#ifdef HAKMEM_TINY_PHASE6_BOX_REFACTOR
+        tiny_ptr = hak_tiny_alloc_fast_wrapper(size);
+#elif defined(HAKMEM_TINY_PHASE6_ULTRA_SIMPLE)
+        tiny_ptr = hak_tiny_alloc_ultra_simple(size);
+#elif defined(HAKMEM_TINY_PHASE6_METADATA)
+        tiny_ptr = hak_tiny_alloc_metadata(size);
+#else
+        tiny_ptr = hak_tiny_alloc(size);
+#endif
+#if HAKMEM_DEBUG_TIMING
+        HKM_TIME_END(HKM_CAT_TINY_ALLOC, t_tiny);
+#endif
+        if (tiny_ptr) { hkm_ace_track_alloc(); return tiny_ptr; }
+        static int log_count = 0; if (log_count < 3) { fprintf(stderr, "[DEBUG] tiny_alloc(%zu) returned NULL, falling back\n", size); log_count++; }
+    }
+
+    hkm_size_hist_record(size);
+
+    if (__builtin_expect(mid_is_in_range(size), 0)) {
+#if HAKMEM_DEBUG_TIMING
+        HKM_TIME_START(t_mid);
+#endif
+        void* mid_ptr = mid_mt_alloc(size);
+#if HAKMEM_DEBUG_TIMING
+        HKM_TIME_END(HKM_CAT_POOL_GET, t_mid);
+#endif
+        if (mid_ptr) return mid_ptr;
+    }
+
+#if HAKMEM_FEATURE_EVOLUTION
+    if (g_evo_sample_mask > 0) {
+        static _Atomic uint64_t tick_counter = 0;
+        if ((atomic_fetch_add(&tick_counter, 1) & g_evo_sample_mask) == 0) {
+            struct timespec now; clock_gettime(CLOCK_MONOTONIC, &now);
+            uint64_t now_ns = now.tv_sec * 1000000000ULL + now.tv_nsec;
+            if (hak_evo_tick(now_ns)) {
+                int new_strategy = hak_elo_select_strategy();
+                atomic_store(&g_cached_strategy_id, new_strategy);
+            }
+        }
+    }
+#endif
+
+    size_t threshold;
+    if (HAK_ENABLED_LEARNING(HAKMEM_FEATURE_ELO)) {
+        int strategy_id = atomic_load(&g_cached_strategy_id);
+        threshold = hak_elo_get_threshold(strategy_id);
+    } else {
+        threshold = 2097152;
+    }
+
+    if (HAK_ENABLED_CACHE(HAKMEM_FEATURE_BIGCACHE) && size >= threshold) {
+        void* cached_ptr = NULL;
+#if HAKMEM_DEBUG_TIMING
+        HKM_TIME_START(t_bc);
+#endif
+        if (hak_bigcache_try_get(size, site_id, &cached_ptr)) {
+#if HAKMEM_DEBUG_TIMING
+            HKM_TIME_END(HKM_CAT_BIGCACHE_GET, t_bc);
+#endif
+            return cached_ptr;
+        }
+#if HAKMEM_DEBUG_TIMING
+        HKM_TIME_END(HKM_CAT_BIGCACHE_GET, t_bc);
+#endif
+    }
+
+    if (size > TINY_MAX_SIZE && size < threshold) {
+        const FrozenPolicy* pol = hkm_policy_get();
+#if HAKMEM_DEBUG_TIMING
+        HKM_TIME_START(t_ace);
+#endif
+        void* l1 = hkm_ace_alloc(size, site_id, pol);
+#if HAKMEM_DEBUG_TIMING
+        HKM_TIME_END(HKM_CAT_POOL_GET, t_ace);
+#endif
+        if (l1) return l1;
+    }
+
+    void* ptr;
+    if (size >= threshold) {
+#if HAKMEM_DEBUG_TIMING
+        HKM_TIME_START(t_mmap);
+#endif
+        ptr = hak_alloc_mmap_impl(size);
+#if HAKMEM_DEBUG_TIMING
+        HKM_TIME_END(HKM_CAT_SYSCALL_MMAP, t_mmap);
+#endif
+    } else {
+#if HAKMEM_DEBUG_TIMING
+        HKM_TIME_START(t_malloc);
+#endif
+        ptr = hak_alloc_malloc_impl(size);
+#if HAKMEM_DEBUG_TIMING
+        HKM_TIME_END(HKM_CAT_FALLBACK_MALLOC, t_malloc);
+#endif
+    }
+    if (!ptr) return NULL;
+
+    if (g_evo_sample_mask > 0) { hak_evo_record_size(size); }
+    AllocHeader* hdr = (AllocHeader*)((char*)ptr - HEADER_SIZE);
+    if (hdr->magic != HAKMEM_MAGIC) { fprintf(stderr, "[hakmem] ERROR: Invalid magic in allocated header!\n"); return ptr; }
+    hdr->alloc_site = site_id;
+    hdr->class_bytes = (size >= threshold) ? threshold : 0;
+
+#if HAKMEM_DEBUG_TIMING
+    HKM_TIME_END(HKM_CAT_HAK_ALLOC, t0);
+#endif
+    return ptr;
+}
+
+#endif // HAK_ALLOC_API_INC_H
+