Micro-optimizations: cache w_end, parallel sort arrays, make_uninit, inline codes

Chain walk: Cache comparison byte w_end to avoid repeated array lookup
per chain iteration. Update w_end only when best_len improves.

Huffman: Split tuple sort array into parallel freq/sym arrays for
better cache locality during insertion sort. Eliminates tuple allocation
and separate leaf_freq/leaf_sym copy step.

Allocations: Use make_uninit_int for leaf_freq, leaf_sym, node_freq,
and RLE all arrays (immediately overwritten, no zeroing needed).
Use make_uninit for BitWriter buffer growth in ensure_capacity.

Block encoding: Cache codes arrays as locals and use unsafe_get to
eliminate method call overhead in the token encoding loop.

321/321 tests, 170/170 parity.

Author: bikallem

flate/bit_writer.mbt

@@ -22,7 +22,7 @@ fn BitWriter::ensure_capacity(self : BitWriter, needed : Int) -> Unit {
     } else {
       self.pos + needed
     }
-    let new_buf = FixedArray::make(new_cap, b'\x00')
+    let new_buf = @blit.make_uninit(new_cap)
     @blit.blit_fixed_array(new_buf, 0, self.buf, 0, self.pos)
     self.buf = new_buf
   }
@@ -202,6 +202,9 @@ fn BitWriter::write_dynamic_block(
     self.write_dynamic_header_precomputed(
       lit_bl, dist_bl, cl_codes, cl_bl, hlit, hdist, hclen, is_final,
     )
+    // Cache codes arrays in locals to avoid method call overhead
+    let lit_c = dyn_lit_codes.codes
+    let dist_c = dyn_dist_codes.codes
     for t in tokens {
       if t.is_match() {
         let length = t.get_length()
@@ -210,7 +213,7 @@ fn BitWriter::write_dynamic_block(
         let length_code = length_encode_table[lidx]
         let length_extra_bits = length_encode_table[lidx + 1]
         let length_extra_val = length_encode_table[lidx + 2]
-        let lentry = dyn_lit_codes.get(length_code)
+        let lentry = lit_c.unsafe_get(length_code)
         self.write_bits_lsb(lentry >> 5, (lentry & 0x1FU).reinterpret_as_int())
         if length_extra_bits > 0 {
           self.write_bits_lsb(
@@ -222,7 +225,7 @@ fn BitWriter::write_dynamic_block(
         let dist_code = dist_encode_table[didx]
         let dist_extra_bits = dist_encode_table[didx + 1]
         let dist_extra_val = dist - dist_base[dist_code]
-        let dentry = dyn_dist_codes.get(dist_code)
+        let dentry = dist_c.unsafe_get(dist_code)
         self.write_bits_lsb(dentry >> 5, (dentry & 0x1FU).reinterpret_as_int())
         if dist_extra_bits > 0 {
           self.write_bits_lsb(
@@ -231,11 +234,11 @@ fn BitWriter::write_dynamic_block(
           )
         }
       } else {
-        let entry = dyn_lit_codes.get(t.get_literal().to_int())
+        let entry = lit_c.unsafe_get(t.get_literal().to_int())
         self.write_bits_lsb(entry >> 5, (entry & 0x1FU).reinterpret_as_int())
       }
     }
-    let eob = dyn_lit_codes.get(END_BLOCK_MARKER)
+    let eob = lit_c.unsafe_get(END_BLOCK_MARKER)
     self.write_bits_lsb(eob >> 5, (eob & 0x1FU).reinterpret_as_int())
   }
 }
@@ -262,7 +265,7 @@ fn BitWriter::write_dynamic_header_precomputed(
     self.write_bits_lsb(cl_bl[code_order[i]].reinterpret_as_uint(), 3)
   }
   let total = hlit + hdist
-  let all = FixedArray::make(total, 0)
+  let all = @blit.make_uninit_int(total)
   for i in 0..<hlit {
     all[i] = lit_bl[i]
   }

flate/deflater.mbt

@@ -511,9 +511,11 @@ fn Deflater::step_lazy(self : Deflater) -> Unit {
       } else {
         max_chain
       }
+      // Cache the comparison byte to avoid repeated array lookup
+      let mut w_end = window.unsafe_get(i + best_len)
       while pos >= 0 && i - pos <= MAX_MATCH_OFFSET && chain_count < chain_limit {
-        if best_len > 0 &&
-          window.unsafe_get(pos + best_len) != window.unsafe_get(i + best_len) {
+        // Skip check: compare byte at best_len position first
+        if window.unsafe_get(pos + best_len) != w_end {
           let next = prev.unsafe_get(pos & WINDOW_MASK)
           if next >= pos {
             break
@@ -529,6 +531,7 @@ fn Deflater::step_lazy(self : Deflater) -> Unit {
           if best_len >= nice || best_len == max_len {
             break
           }
+          w_end = window.unsafe_get(i + best_len)
         }
         let next = prev.unsafe_get(pos & WINDOW_MASK)
         if next >= pos {

flate/huffman_encoder.mbt

@@ -74,34 +74,35 @@ fn compute_bit_lengths(
     }
     return bit_lengths
   }
-  let sorted = FixedArray::make(active, (0, 0))
+  // Use parallel arrays instead of tuple array for better cache locality
+  let leaf_freq = @blit.make_uninit_int(active)
+  let leaf_sym = @blit.make_uninit_int(active)
   for i = 0, idx = 0; i < n; {
     if freqs[i] > 0 {
-      sorted[idx] = (freqs[i], i)
+      leaf_freq[idx] = freqs[i]
+      leaf_sym[idx] = i
       continue i + 1, idx + 1
     }
     continue i + 1, idx
   }
+  // Insertion sort by frequency (parallel arrays)
   for i in 1..<active {
-    let key = sorted[i]
+    let kf = leaf_freq[i]
+    let ks = leaf_sym[i]
     let mut j = i - 1
-    while j >= 0 && sorted[j].0 > key.0 {
-      sorted[j + 1] = sorted[j]
+    while j >= 0 && leaf_freq[j] > kf {
+      leaf_freq[j + 1] = leaf_freq[j]
+      leaf_sym[j + 1] = leaf_sym[j]
       j -= 1
     }
-    sorted[j + 1] = key
-  }
-  let leaf_freq = FixedArray::make(active, 0)
-  let leaf_sym = FixedArray::make(active, 0)
-  for i, entry in sorted {
-    leaf_freq[i] = entry.0
-    leaf_sym[i] = entry.1
+    leaf_freq[j + 1] = kf
+    leaf_sym[j + 1] = ks
   }
   let total_nodes = 2 * active - 1
   let parent = FixedArray::make(total_nodes, -1)
-  let node_freq = FixedArray::make(total_nodes, 0)
-  for i, f in leaf_freq {
-    node_freq[i] = f
+  let node_freq = @blit.make_uninit_int(total_nodes)
+  for i in 0..<active {
+    node_freq[i] = leaf_freq[i]
   }
   let mut leaf_ptr = 0
   let mut int_ptr = active
@@ -308,7 +309,7 @@ fn rle_count_freqs(
   cl_freqs : FixedArray[Int],
 ) -> Unit {
   let total = hlit + hdist
-  let all = FixedArray::make(total, 0)
+  let all = @blit.make_uninit_int(total)
   for i in 0..<hlit {
     all[i] = lit_bl[i]
   }