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/Buffer/FixedStackString.tt

@@ -0,0 +1,129 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".cs" #>
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Misaki.HighPerformance.LowLevel.Buffer;
+
+<# for (int i = 32; i <= 4096; i *= 2) { #>
+/// <summary>
+/// Represents a stack allocated fixed-size UTF-8 encoded string of length <#= i #> bytes.
+/// </summary>
+/// <remarks>
+/// This struct is designed to hold data on the stack. Every copy of this struct causes a copy of the underlying data.
+/// If you need a heap allocated fixed-size UTF-8 encoded string of length <#= i #> bytes, consider using <see cref="Misaki.HighPerformance.Unsafe.Buffer.FixedString<#= i #>"/>.
+/// </remarks>
+[StructLayout(LayoutKind.Sequential, Size = <#= i #>)]
+public unsafe struct FixedStackString<#= i #>
+{
+    private ushort _length;
+    private fixed byte _buffer[<#= i - 2 #>];
+
+    public ushort Length => _length;
+    public string Value
+    {
+        get
+        {
+            fixed (byte* bufferPtr = _buffer)
+            {
+                return Encoding.UTF8.GetString(bufferPtr, _length);
+            }
+        }
+        set
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                _length = 0;
+                return;
+            }
+
+            var maxBytes = Encoding.UTF8.GetByteCount(value);
+            if (maxBytes > <#= i - 2 #>)
+            {
+                throw new ArgumentException("Input string is too long to fit in FixedStackString<#= i #>.");
+            }
+
+            fixed (byte* bufferPtr = _buffer)
+            {
+                _length = (ushort)Encoding.UTF8.GetBytes(value, new Span<byte>(bufferPtr, <#= i - 2 #>));
+            }
+        }
+    }
+
+    public FixedStackString<#= i #>(ReadOnlySpan<char> input)
+    {
+        var maxBytes = Encoding.UTF8.GetByteCount(input);
+        if (maxBytes > <#= i - 2 #>)
+        {
+            throw new ArgumentException("Input string is too long to fit in FixedString<#= i #>.");
+        }
+
+        fixed (char* inputPtr = input)
+        fixed (byte* bufferPtr = _buffer)
+        {
+            var actualByteCount = Encoding.UTF8.GetBytes(inputPtr, input.Length, bufferPtr, <#= i - 2 #>);
+            _length = (ushort)actualByteCount;
+        }
+    }
+
+    public FixedStackString<#= i #>(string input)
+        : this(input.AsSpan())
+    {
+    }
+
+    public FixedStackString<#= i #>(char* input, ushort length)
+        : this(new Span<char>(input, length))
+    {
+    }
+
+    public FixedStackString<#= i #>(ReadOnlySpan<byte> input)
+    {
+        if (input.Length > <#= i - 2 #>)
+        {
+            throw new ArgumentException("Input byte array is too long to fit in FixedString<#= i #>.");
+        }
+
+        _length = (ushort)input.Length;
+
+        fixed (byte* inputPtr = input)
+        fixed (byte* bufferPtr = _buffer)
+        {
+            SystemUnsfae.CopyBlockUnaligned(bufferPtr, inputPtr, _length);
+        }
+    }
+
+    public FixedStackString<#= i #>(byte* input, ushort length)
+        : this(new ReadOnlySpan<byte>(input, length))
+    {
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Span<byte> AsSpan()
+    {
+        fixed (byte* ptr = _buffer)
+        {
+            return new(ptr, _length);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public byte* GetUnsafePointer()
+    {
+        fixed (byte* ptr = _buffer)
+        {
+            return ptr;
+        }
+    }
+
+    public override string ToString()
+    {
+        return Value;
+    }
+}
+
+<# } #>