fix(gzip): reuse caller output buffer

- Inflate single-member streams directly into the supplied output buffer.
- Preserve ISIZE bounds checks without allocating and copying a temporary buffer.
- Add regression coverage for buffer identity and decoded contents.

Author: hustcer

src/gzip.mbt

@@ -102,6 +102,23 @@ fn gzhl(o : GzipOptions) -> Int {
   10 + (if o.filename.length() > 0 { o.filename.length() + 1 } else { 0 })
 }
 
+///|
+/// Select the fixed output buffer for the single-member fast path.
+fn single_member_gunzip_buffer(
+  isize : Int,
+  out : FixedArray[Byte]?,
+) -> FixedArray[Byte] raise FzipError {
+  match out {
+    Some(buf) => {
+      if isize > buf.length() {
+        raise fzip_err(InvalidZipData, msg="output buffer too small")
+      }
+      buf
+    }
+    None => FixedArray::make(isize, b'\x00')
+  }
+}
+
 ///|
 /// Try the fixed-buffer one-shot path used by ordinary single-member streams.
 /// Return `None` when the first DEFLATE stream ends before the final footer or
@@ -120,11 +137,12 @@ fn try_gunzip_single_member(
     None
   }
   let inflate_st = InflateState::new(2)
+  let output = single_member_gunzip_buffer(isize, opts.out)
   let (buf, len) = try
     inflt(
       data,
       inflate_st,
-      Some(FixedArray::make(isize, b'\x00')),
+      Some(output),
       opts.dictionary,
       opts.max_input_size,
       opts.max_output_size,
@@ -160,18 +178,7 @@ fn try_gunzip_single_member(
   if len != isize {
     raise fzip_err(InvalidZipData, msg="gzip ISIZE mismatch")
   }
-  Some(
-    match opts.out {
-      Some(out) => {
-        if len > out.length() {
-          raise fzip_err(InvalidZipData, msg="output buffer too small")
-        }
-        buf.blit_to(out, len~, dst_offset=0)
-        trim_buf(out, len)
-      }
-      None => trim_buf(buf, len)
-    },
-  )
+  Some(trim_buf(buf, len))
 }
 
 ///|

src/gzip_wbtest.mbt

@@ -144,6 +144,25 @@ test "gunzip - trims oversized caller output buffer" {
   }
 }
 
+///|
+test "gunzip - single-member fast path reuses caller output buffer" {
+  let out = FixedArray::make(5, b'\x00')
+  let selected = single_member_gunzip_buffer(5, Some(out))
+  assert_true(physical_equal(selected, out))
+  let data : FixedArray[Byte] = [b'H', b'e', b'l', b'l', b'o']
+  let result = gunzip_sync(gzip_sync(data), opts={
+    out: Some(out),
+    dictionary: None,
+    max_output_size: default_max_output_size,
+    max_input_size: default_max_input_size,
+    verify_checksum: true,
+  })
+  assert_true(physical_equal(result, out))
+  for i in 0..<data.length() {
+    assert_eq(result[i], data[i])
+  }
+}
+
 ///|
 test "gzip level 9" {
   let data : FixedArray[Byte] = [1, 2, 3, 4, 5]