[C#] Update RawTableIterBase.Enumerator to use ArrayPool for buffer (#4385)

This is the implementation of a fix for #4093 

# Description of Changes

* Updated `RawTableIterBase.Enumerator` to rent its scratch buffer from
`ArrayPool<byte>.Shared` (with dynamic re-rent on `BUFFER_TOO_SMALL`)
and return it on dispose, so iterating rows no longer allocates a fresh
`byte[]` per step.
* The enumerator still exposes the row bytes via `ArraySegment<byte>
Current`, but now the underlying storage is reused across iterations
rather than recreated each time.

Testing results from `master`:
```
allocated_bytes=14000
elapsed_ticks=1521829
sum=1249975000
row_count=50000
Find() TinyRecord (8 bytes payload) -> 132208 bytes allocated
Find() MediumRecord (~50 bytes payload) -> 132440 bytes allocated
Find() LargeRecord (1 KB payload) -> 134528 bytes allocated
Find() LargeRecord (10 KB payload) -> 152408 bytes allocated
Find() LargeRecord (100 KB payload) -> 336728 bytes allocated
Iter() 10 rows -> 131896 bytes allocated
Filter() iterate 20 rows -> 133288 bytes allocated
Filter() iterate 100 rows -> 135976 bytes allocated
10x consecutive Find() (TinyRecord) -> 1319120 bytes allocated
```

Testing results with this fix:
```
allocated_bytes=14000
elapsed_ticks=1504949
sum=1249975000
row_count=50000
Find() TinyRecord (8 bytes payload) -> 1096 bytes allocated
Find() MediumRecord (~50 bytes payload) -> 1280 bytes allocated
Find() LargeRecord (1 KB payload) -> 4464 bytes allocated
Find() LargeRecord (10 KB payload) -> 27464 bytes allocated
Find() LargeRecord (100 KB payload) -> 234312 bytes allocated
Iter() 10 rows -> 680 bytes allocated
Filter() iterate 20 rows -> 1872 bytes allocated
Filter() iterate 100 rows -> 3280 bytes allocated
10x consecutive Find() (TinyRecord) -> 8000 bytes allocated
```
# API and ABI breaking changes

No API or ABI changes

# Expected complexity level and risk

2 - low/moderate:
Touches the hot-path iterator that every `Iter`/`Find`/`Filter` call
uses

# Testing

- [X] Compiled CLI and ran regression tests locally
- [X] Verified iterator-based harness runs (client + module reducers) on
both `master` and this branch, confirming allocations drop from ~131 KB
per read to payload-scaled values.
- [X] Ensured no regressions in standard harness sanity checks
(`row_count=50000`, `sum=1249975000`).

Author: rekhoff

crates/bindings-csharp/Runtime/Internal/ITable.cs

@@ -1,14 +1,16 @@
 namespace SpacetimeDB.Internal;
 
+using System.Buffers;
 using SpacetimeDB.BSATN;
 
 internal abstract class RawTableIterBase<T>
     where T : IStructuralReadWrite, new()
 {
     public sealed class Enumerator(FFI.RowIter handle) : IDisposable
     {
-        byte[] buffer = new byte[0x20_000];
-        public byte[] Current { get; private set; } = [];
+        private const int InitialBufferSize = 1024;
+        private byte[]? buffer = ArrayPool<byte>.Shared.Rent(InitialBufferSize);
+        public ArraySegment<byte> Current { get; private set; } = ArraySegment<byte>.Empty;
 
         public bool MoveNext()
         {
@@ -17,6 +19,11 @@ public bool MoveNext()
                 return false;
             }
 
+            if (buffer is null)
+            {
+                return false;
+            }
+
             uint buffer_len;
             while (true)
             {
@@ -38,11 +45,10 @@ public bool MoveNext()
                 {
                     // Iterator advanced and may also be `EXHAUSTED`.
                     // When `OK`, we'll need to advance the iterator in the next call to `MoveNext`.
-                    // In both cases, copy over the row data to `Current` from the scratch `buffer`.
+                    // In both cases, update `Current` to point at the valid range in the scratch `buffer`.
                     case Errno.EXHAUSTED
                     or Errno.OK:
-                        Current = new byte[buffer_len];
-                        Array.Copy(buffer, 0, Current, 0, buffer_len);
+                        Current = new ArraySegment<byte>(buffer, 0, (int)buffer_len);
                         return buffer_len != 0;
                     // Couldn't find the iterator, error!
                     case Errno.NO_SUCH_ITER:
@@ -51,7 +57,8 @@ public bool MoveNext()
                     // Grow `buffer` and try again.
                     // The `buffer_len` will have been updated with the necessary size.
                     case Errno.BUFFER_TOO_SMALL:
-                        buffer = new byte[buffer_len];
+                        ArrayPool<byte>.Shared.Return(buffer);
+                        buffer = ArrayPool<byte>.Shared.Rent((int)buffer_len);
                         continue;
                     default:
                         throw new UnknownException(ret);
@@ -66,6 +73,12 @@ public void Dispose()
                 FFI.row_iter_bsatn_close(handle);
                 handle = FFI.RowIter.INVALID;
             }
+
+            if (buffer is not null)
+            {
+                ArrayPool<byte>.Shared.Return(buffer);
+                buffer = null;
+            }
         }
 
         public void Reset()
@@ -87,7 +100,13 @@ public IEnumerable<T> Parse()
     {
         foreach (var chunk in this)
         {
-            using var stream = new MemoryStream(chunk);
+            using var stream = new MemoryStream(
+                chunk.Array!,
+                chunk.Offset,
+                chunk.Count,
+                writable: false,
+                publiclyVisible: true
+            );
             using var reader = new BinaryReader(stream);
             while (stream.Position < stream.Length)
             {