feat(Phase 1-2): Add atomic initialization wait mechanism (safety improvement)

Implements thread-safe atomic initialization tracking and a wait helper for
non-init threads to avoid libc fallback during the initialization window.

Changes:
- Convert g_initializing to _Atomic type for thread-safe access
- Add g_init_thread to identify which thread performs initialization
- Implement hak_init_wait_for_ready() helper with spin/yield mechanism
- Update hak_core_init.inc.h to use atomic operations
- Update hak_wrappers.inc.h to call wait helper instead of checking g_initializing

Results & Analysis:
- Performance: ±0% (21s → 21s, no measurable improvement)
- Safety: ✓ Prevents recursion in init window
- Investigation: Initialization overhead is <1% of total allocations
  - Expected: 2-8% improvement
  - Actual: 0% improvement (spin/yield overhead ≈ savings)
  - libc overhead: 41% → 57% (relative increase, likely sampling variation)

Key Findings from Perf Analysis:
- getenv: 0% (maintained from Phase 1-1) ✓
- libc malloc/free: ~24.54% of cycles
- libc fragmentation (malloc_consolidate/unlink_chunk): ~16% of cycles
- Total libc overhead: ~41% (difficult to optimize without changing algorithm)

Next Phase Target:
- Phase 2: Investigate libc fragmentation (malloc_consolidate 9.33%, unlink_chunk 6.90%)
- Potential approaches: hakmem Mid/ACE allocator expansion, sh8bench pattern analysis

Recommendation: Keep Phase 1-2 for safety (no performance regression), proceed to Phase 2.

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

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

core/box/hak_core_init.inc.h

@@ -33,7 +33,8 @@ void hak_init(void) {
 }
 
 static void hak_init_impl(void) {
-    g_initializing = 1;
+    g_init_thread = pthread_self();
+    atomic_store_explicit(&g_initializing, 1, memory_order_release);
 
     // Phase 6.X P0 FIX (2025-10-24): Initialize Box 3 (Syscall Layer) FIRST!
     // This MUST be called before ANY allocation (Tiny/Mid/Large/Learner)
@@ -313,7 +314,7 @@ static void hak_init_impl(void) {
     }
 #endif
 
-    g_initializing = 0;
+    atomic_store_explicit(&g_initializing, 0, memory_order_release);
     // Publish that initialization is complete
     atomic_thread_fence(memory_order_seq_cst);
     g_initialized = 1;