fix(memory): add GC memory pressure tracking for unmanaged allocations

Fixes GitHub issue #501 where memory would grow to 10GB+ when creating
many NDArrays in a loop without explicit GC.Collect() calls.

Root cause: NumSharp allocates data via NativeMemory.Alloc (unmanaged)
but did not inform the GC about this memory pressure. The GC only saw
small managed objects (~100 bytes each) and didn't know about the
~880+ bytes of unmanaged data per array, so it would not trigger
collections frequently enough.

Fix: Add GC.AddMemoryPressure() when allocating unmanaged memory and
GC.RemoveMemoryPressure() when freeing it. This informs the GC about
the true memory footprint so it schedules collections appropriately.

Before fix: Creating 1M arrays with 110 doubles each peaked at 10+ GB
After fix:  Same workload peaks at ~54 MB (stable, proper GC behavior)

Changes:
- Disposer constructor now takes bytesCount parameter for Native allocs
- Call GC.AddMemoryPressure(bytesCount) on allocation
- Call GC.RemoveMemoryPressure(bytesCount) on deallocation

Author: Nucs

src/NumSharp.Core/Backends/Unmanaged/UnmanagedMemoryBlock`1.cs

@@ -29,7 +29,7 @@ public UnmanagedMemoryBlock(long count)
         {
             var bytes = BytesCount = count * InfoOf<T>.Size;
             var ptr = (IntPtr)NativeMemory.Alloc((nuint)bytes);
-            _disposer = new Disposer(ptr);
+            _disposer = new Disposer(ptr, bytes);
             Address = (T*)ptr;
             Count = count;
         }
@@ -984,16 +984,24 @@ private enum AllocationType
             private readonly IntPtr Address;
             private readonly GCHandle _gcHandle;
             private readonly Action _dispose;
+            private readonly long _bytesCount;
 
 
             /// <summary>
             ///     Construct a AllocationType.Native (NativeMemory.Alloc)
             /// </summary>
-            /// <param name="address"></param>
-            public Disposer(IntPtr address)
+            /// <param name="address">The address of the allocated memory.</param>
+            /// <param name="bytesCount">The size in bytes of the allocation (for GC memory pressure tracking).</param>
+            public Disposer(IntPtr address, long bytesCount)
             {
                 Address = address;
+                _bytesCount = bytesCount;
                 _type = AllocationType.Native;
+
+                // Inform the GC about unmanaged memory allocation so it can
+                // schedule collections appropriately (fixes GitHub issue #501)
+                if (bytesCount > 0)
+                    GC.AddMemoryPressure(bytesCount);
             }
 
             /// <summary>
@@ -1036,6 +1044,9 @@ private void ReleaseUnmanagedResources()
                 {
                     case AllocationType.Native:
                         NativeMemory.Free((void*)Address);
+                        // Remove GC memory pressure that was added during allocation
+                        if (_bytesCount > 0)
+                            GC.RemoveMemoryPressure(_bytesCount);
                         return;
                     case AllocationType.Wrap:
                         return;