perf(inflate): widen [512,2048)-byte initial output estimate to 160x

fzip's two-block periodic encoder now packs 100 KiB into ~700-750 bytes (~140x),
which fell just under the previous 96x initial-buffer estimate and forced a
mid-decode realloc plus a full-buffer copy. Inputs this small are exactly the
ones most likely to be highly compressible (runs, periodic, sparse), so bias the
estimate higher for this size class; the buffer is trimmed to the exact length
afterwards, and output is byte-identical.

inflate decompress (native, isolated, 100K periodic seq):
- raw deflate: 15.17 -> 12.91 us (-14.9%)
  back to ~flat vs the pre-periodic baseline (12.17 us); the residual is the
  bulk block's tiny dynamic-table build.

- <512-byte and >=2048-byte inputs are untouched (zeros/random unaffected).
- All 367 tests pass on wasm-gc, native, js. No public API change.

Author: hustcer

src/inflate.mbt

@@ -25,7 +25,13 @@ fn initial_inflate_size(sl : Int, max_output_size : Int) -> Int raise FzipError
   }
   let base = sl * 3
   if sl >= 512 && sl < 2048 {
-    let expanded = sl * 96
+    // Small inputs in this range are frequently highly compressible (runs,
+    // periodic data, sparse buffers) and expand by well over 100x. fzip's
+    // periodic encoder packs 100 KiB into ~700 bytes (~140x), so a smaller
+    // multiplier would force a mid-decode realloc + buffer copy. Estimate
+    // generously here (the buffer is trimmed to the exact length afterwards)
+    // so these streams decode in a single allocation.
+    let expanded = sl * 160
     if expanded > max_output_size {
       max_output_size
     } else {

src/inflate_wbtest.mbt

@@ -102,9 +102,13 @@ test "inflate/high_ratio_preallocation/100kb_sequential" {
 
 ///|
 test "inflate initial size heuristic" {
+  // sl < 512 and sl >= 2048 use the proportional base estimate (sl * 3).
   assert_eq(initial_inflate_size(100, default_max_output_size), 300)
-  assert_eq(initial_inflate_size(512, default_max_output_size), 49152)
   assert_eq(initial_inflate_size(2048, default_max_output_size), 6144)
+  // [512, 2048) is biased high (sl * 160) because inputs this small are often
+  // highly compressible (runs/periodic) and expand >100x; the generous estimate
+  // lets them decode in a single allocation.
+  assert_eq(initial_inflate_size(512, default_max_output_size), 81920)
 }
 
 ///|