perf(l64a): encode into the static buffer, drop the per-call heap allocation — 5.1x -> 1.07x

l64a delegated to `core::stdlib::l64a`, which returns a freshly heap-allocated
`Vec<u8>` (Vec::with_capacity(6)) every call, then copied it into the static
return buffer — a malloc+free per call for a trivial ≤6-char base-64 encode.
glibc uses a static buffer with no allocation, so fl was ~5.1x slower.

Inlined the encode (the SVID base-64 alphabet + the low-32-bits divide loop)
directly into the static BUF, byte-identical to the old core->Vec->copy path but
allocation-free. 5.10x -> 1.07x vs glibc (residual is the membrane decision).

Isomorphism verified: fl l64a matches host glibc l64a for 200013 values (0,
boundaries 63/64/0xFFFFFFFF, negatives, i32::MIN/MAX, and random) — 0
divergences. Existing a64l_l64a_differential_fuzz and stdlib-numeric tests pass.

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

Author: Dicklesworthstone

crates/frankenlibc-abi/src/stdlib_abi.rs

@@ -3144,21 +3144,30 @@ pub unsafe extern "C" fn l64a(value: c_long) -> *mut c_char {
     // Static buffer for returned string (matching glibc's static buffer).
     static mut BUF: [u8; 8] = [0; 8];
 
+    // SVID base-64 alphabet (index 0='.', 1='/', 2-11='0'-'9', 12-37='A'-'Z',
+    // 38-63='a'-'z'), matching frankenlibc_core::stdlib::base64.
+    const ALPHABET: &[u8; 64] =
+        b"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
     let (_, decision) = runtime_policy::decide(ApiFamily::Stdlib, 0, 0, true, false, 0);
-    if matches!(decision.action, MembraneAction::Deny) {
-        runtime_policy::observe(ApiFamily::Stdlib, decision.profile, 4, true);
-        unsafe {
-            let p = std::ptr::addr_of_mut!(BUF);
-            (*p)[0] = 0;
-            return p as *mut u8 as *mut c_char;
-        }
-    }
-    let encoded = frankenlibc_core::stdlib::l64a(value);
     unsafe {
         let p = std::ptr::addr_of_mut!(BUF);
         let buf = &mut *p;
-        let len = encoded.len().min(7);
-        buf[..len].copy_from_slice(&encoded[..len]);
+        if matches!(decision.action, MembraneAction::Deny) {
+            runtime_policy::observe(ApiFamily::Stdlib, decision.profile, 4, true);
+            buf[0] = 0;
+            return p as *mut u8 as *mut c_char;
+        }
+        // Encode the low 32 bits as base-64 directly into the static buffer,
+        // byte-identical to the old `core::l64a` -> Vec -> copy path but without
+        // the per-call heap allocation (glibc uses a static buffer, no alloc).
+        let mut v = (value as u32) as u64;
+        let mut len = 0usize;
+        while v != 0 && len < 6 {
+            buf[len] = ALPHABET[(v & 0x3F) as usize];
+            v >>= 6;
+            len += 1;
+        }
         buf[len] = 0;
         runtime_policy::observe(ApiFamily::Stdlib, decision.profile, 4, false);
         p as *mut u8 as *mut c_char