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/hakmem.c

@@ -36,6 +36,7 @@
 #include <dlfcn.h>
 #include <stdatomic.h>  // NEW Phase 6.5: For atomic tick counter
 #include <pthread.h>    // Phase 6.15: Threading primitives (recursion guard only)
+#include <sched.h>      // Yield during init wait
 #include <errno.h>      // calloc overflow handling
 #include <signal.h>
 #ifdef __GLIBC__
@@ -243,8 +244,34 @@ int hak_in_wrapper(void) {
 }
 
 // Initialization guard
-static int g_initializing = 0;
-int hak_is_initializing(void) { return g_initializing; }
+static _Atomic int g_initializing = 0;
+static pthread_t g_init_thread;
+int hak_is_initializing(void) { return atomic_load_explicit(&g_initializing, memory_order_acquire); }
+
+// Wait helper for non-init threads to avoid libc fallback during init window
+static inline int hak_init_wait_for_ready(void) {
+    if (__builtin_expect(!atomic_load_explicit(&g_initializing, memory_order_acquire), 1)) {
+        return 1;  // Ready
+    }
+    pthread_t self = pthread_self();
+    if (pthread_equal(self, g_init_thread)) {
+        return 0;  // We are the init thread; caller should take the existing fallback path
+    }
+    for (int i = 0; atomic_load_explicit(&g_initializing, memory_order_acquire); ++i) {
+#if defined(__x86_64__) || defined(__i386__)
+        if (i < 1024) {
+            __asm__ __volatile__("pause" ::: "memory");
+        } else
+#endif
+        {
+            sched_yield();
+        }
+        if (i > 1000000) {
+            return -1;  // Timed out waiting for init; allow libc fallback
+        }
+    }
+    return 1;  // Init completed
+}
 
 // ============================================================================
 // Phase 6-1.5: Ultra-Simple Fast Path Forward Declarations