Add image processing and memory management features

Added new namespace `Misaki.HighPerformance.Image` for image processing, including classes for animated GIF handling and memory management.
Added `AnimatedFrameResult` class for individual frames in animated images.
Added `AnimatedGifEnumerator` class for enumerating frames in animated GIFs.
Added `ColorComponents` enum for different color formats.
Added `ImageInfo` struct for image dimensions and color components.
Added `CRuntime` class for low-level memory management functions.
Added `MemoryStats` class to track memory allocation statistics.
Added utility functions for creating multi-dimensional arrays.
Added new structures for fixed-size UTF-8 encoded strings.
Added benchmarking classes to test new memory management features.

Changed `StbImage.cs` to include new namespaces and functionality for image data manipulation.
Changed project files to target .NET 9.0 and enable new features.
Changed `Arena.cs` and `DynamicArena.cs` to use `nuint` for size parameters.
Changed `BitSet.cs` to enhance bit manipulation methods.
Changed `Program.cs` to run `FunctionPtrBenchmark` for performance testing.

Removed memory tracking code from `AllocationManager.cs`, including the `_allocated` dictionary and related logic.
Removed `Free` method from `IAllocator.cs` interface.
Removed `UNSAFE_COLLECTION_CHECK` preprocessor directive from the codebase.

Refactored various files to improve organization, moving from `Unsafe` to `LowLevel` namespace.
Refactored `MemoryUtilities` class to include new memory operation methods.
Refactored `UnsafeUtilities.cs` to support new collection structures.

Misaki.HighPerformance.LowLevel/Collections/UnsafeArray.cs

@@ -0,0 +1,186 @@
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections.Contracts;
+using Misaki.HighPerformance.LowLevel.Contracts;
+using Misaki.HighPerformance.LowLevel.Helpers;
+using System.Collections;
+using System.Runtime.CompilerServices;
+
+namespace Misaki.HighPerformance.LowLevel.Collections;
+
+/// <summary>
+/// A structure for managing an array of unmanaged types with unsafe memory operations.
+/// </summary>
+/// <typeparam name="T">Represents a type that can be stored in an unmanaged memory context.</typeparam>
+public unsafe struct UnsafeArray<T> : IUnsafeCollection<T>
+    where T : unmanaged
+{
+    public struct Enumerator : IEnumerator<T>
+    {
+        private UnsafeArray<T>* _collection;
+        private int _index;
+        private T _value;
+
+        public Enumerator(UnsafeArray<T>* collection)
+        {
+            _collection = collection;
+            _index = -1;
+            _value = default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool MoveNext()
+        {
+            _index++;
+            if (_index < _collection->_count)
+            {
+                _value = UnsafeUtilities.ReadArrayElement<T>(_collection->_buffer, _index);
+                return true;
+            }
+
+            _value = default;
+            return false;
+        }
+
+        public void Reset()
+        {
+            _index = -1;
+        }
+
+        // Let NativeArray indexer check for out of range.
+        public readonly T Current
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _value;
+        }
+
+        readonly object IEnumerator.Current
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => Current;
+        }
+
+        public void Dispose()
+        {
+        }
+    }
+
+    private T* _buffer;
+    private int _count;
+
+    private AllocationHandle* _handle;
+
+    public readonly int Count => _count;
+
+    public readonly ref T this[int index]
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get
+        {
+            if (index < 0 || index >= _count)
+            {
+                throw new ArgumentOutOfRangeException(nameof(index), "Index is out of range.");
+            }
+
+            return ref _buffer[index];
+        }
+    }
+
+    public readonly bool IsCreated
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => _buffer != null;
+    }
+
+    public IEnumerator<T> GetEnumerator() => new Enumerator((UnsafeArray<T>*)UnsafeUtilities.AddressOf(ref this));
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+    /// <summary>
+    /// Constructs an UnsafeArray with a default size of 1 and uses the Persistent allocator.
+    /// </summary>
+    public UnsafeArray()
+        : this(1, Allocator.Persistent)
+    {
+    }
+
+    public UnsafeArray(int count, ref AllocationHandle handle, AllocationOption allocationOption = AllocationOption.None)
+    {
+        if (count <= 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(count), "Count must be greater than zero.");
+        }
+
+        _handle = (AllocationHandle*)Unsafe.AsPointer(ref handle);
+        _buffer = (T*)handle.Alloc(_handle->Allocator, (uint)count * (uint)sizeof(T), (uint)AlignOf<T>(), allocationOption);
+        _count = count;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of UnsafeArray with a specified number of elements and an allocation type.
+    /// </summary>
+    /// <param name="count">Specifies the number of elements to allocate in the array, which must be greater than zero.</param>
+    /// <param name="allocator">Specifies the allocator to use for memory allocation, which determines the memory management strategy.</param>
+    /// <param name="allocationOption">Determines how the memory should be allocated.</param>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when the specified number of elements is less than or equal to zero.</exception>
+    public UnsafeArray(int count, Allocator allocator, AllocationOption allocationOption = AllocationOption.None)
+        : this(count, ref AllocationManager.GetAllocationHandle(allocator), allocationOption)
+    {
+    }
+
+    /// <summary>
+    /// Initializes an UnsafeArray with a pointer to a buffer and a count of elements. This does not copy the data.
+    /// </summary>
+    /// <param name="buffer">A pointer to the memory location that holds the elements of the array.</param>
+    /// <param name="count">The total size of the data.</param>
+    /// <remarks>
+    /// When using this constructor, the user is responsible for managing the memory pointed to by the buffer.
+    /// Disposing of the UnsafeArray does not free the memory and only release the reference. The memory should be freed manually when no longer needed.
+    /// Use <see cref="UnsafeArray(int, Allocator, AllocationOption)"/> constructor and <see cref="MemCpy(void*, void*, nuint)"/> if you are not sure what you are doing.
+    /// </remarks>
+    public UnsafeArray(void* buffer, int count)
+    {
+        _buffer = (T*)buffer;
+        _count = count;
+        _handle = (AllocationHandle*)Unsafe.AsPointer(ref AllocationManager.EmptyAllocator.Handle);
+    }
+
+    /// <inheritdoc/>
+    public void Resize(int newSize)
+    {
+        if (newSize == _count)
+        {
+            return;
+        }
+
+        _buffer = (T*)_handle->Realloc(_handle->Allocator, _buffer, (uint)newSize, (uint)AlignOf<T>());
+        _count = newSize;
+    }
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly void Clear()
+    {
+        MemClear(_buffer, (nuint)(_count * sizeof(T)));
+    }
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly void* GetUnsafePtr()
+    {
+        return _buffer;
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        if (!IsCreated)
+        {
+            return;
+        }
+
+        _handle->Free(_handle->Allocator, _buffer);
+
+        _handle = null;
+        _buffer = null;
+        _count = 0;
+    }
+}