Refactor unsafe collections and benchmarks

Changed the `CollectionBenchmark` class to use unsafe code for improved memory operations and added benchmarks for stack-allocated arrays.
Changed the `ParallelNoiseBenchmark` class to remove the internal `NoiseJob` struct, promoting better organization.
Changed the `AllocationManager` class to remove the lock mechanism for thread safety and simplified the `Reset` method.
Changed the `Arena` and `DynamicArena` structs to include `Initialize` methods for better initialization control.
Changed the `UnsafeArray<T>`, `UnsafeHashSet<T>`, and `UnsafeList<T>` structs to improve element access and management.
Updated the `UnsafeCollectionExtensions` class to enhance usability with new methods for copying and converting collections.
Updated the `MemoryLeakException` class to provide more detailed stack trace information for better debugging.
Removed the usage of `UnsafeHashMap` in `Program.cs` and directly ran the `CollectionBenchmark`.
Added a new `NoiseJob` struct in `NoiseJob.cs` for generating gradient noise using `UnsafeArray<float>`.
Fixed minor typos and improved method signatures throughout the codebase for clarity.

Misaki.HighPerformance.Test/CollectionBenchmark.cs

@@ -5,28 +5,45 @@ using Misaki.HighPerformance.Unsafe.Collections;
 namespace Misaki.HighPerformance.Test;
 
 [MemoryDiagnoser]
-public class CollectionBenchmark
+public unsafe class CollectionBenchmark
 {
     [Params(10, 100, 1000)]
-    public int count = 100;
+    public int count;
 
     [GlobalSetup]
     public void Setup()
     {
-        AllocationManager.Initialize(512_000);
+        AllocationManager.Initialize();
     }
 
     [Benchmark]
     public void Array()
     {
         var array = new int[count];
+        for (var i = 0; i < count; i++)
+        {
+            array[i] = i;
+        }
     }
 
-    [Benchmark]
+    [Benchmark(Baseline = true)]
     public void UnsafeArray()
     {
         var array = new UnsafeArray<int>(count, Allocator.Temp);
-        AllocationManager.Reset();
+        for (var i = 0; i < count; i++)
+        {
+            array[i] = i;
+        }
+    }
+
+    [Benchmark]
+    public void StackArray()
+    {
+        var array = stackalloc int[count];
+        for (var i = 0; i < count; i++)
+        {
+            array[i] = i;
+        }
     }
 
     [GlobalCleanup]