Add high-performance unmanaged HashMap and tests

Introduced a high-performance, unmanaged `HashMap<TKey, TValue>`
optimized for .NET 8.0 or greater. The implementation includes
SIMD-based probing, alignment-aware memory management, and
dynamic resizing for efficient operations. Added a `Tag` system
to manage hash table slot states and utility methods for probing
and hashing.

Added `AlignmentHelper` for aligning values up or down to the
nearest multiple of a given alignment.

Included a comprehensive test suite (`HashMapTests.cs`) to verify
the correctness of the `HashMap` implementation, covering
operations like adding, retrieving, resizing, and removing
elements.

Author: JunaMeinhold

Hexa.NET.Utilities.Tests/HashMapTests.cs

@@ -0,0 +1,83 @@
+namespace Hexa.NET.Utilities.Tests
+{
+    [TestFixture]
+    public unsafe class HashMapTests
+    {
+        [Test]
+        public void AddAndContainsWorks()
+        {
+            HashMap<int, int> map = new();
+            map.EnsureCapacity(8);
+            map.Add(1, 100);
+            map.Add(2, 200);
+            Assert.That(map.Contains(1), Is.True);
+            Assert.That(map.Contains(2), Is.True);
+            Assert.That(map.Contains(3), Is.False);
+            map.Release();
+        }
+
+        [Test]
+        public void TryGetValueReturnsCorrectValue()
+        {
+            HashMap<int, int> map = new();
+            map.EnsureCapacity(8);
+            map.Add(42, 420);
+            map.Add(7, 70);
+            Assert.That(map.TryGetValue(42, out var v1), Is.True);
+            Assert.That(v1, Is.EqualTo(420));
+            Assert.That(map.TryGetValue(7, out var v2), Is.True);
+            Assert.That(v2, Is.EqualTo(70));
+            Assert.That(map.TryGetValue(99, out var v3), Is.False);
+            map.Release();
+        }
+
+        [Test]
+        public void AddDuplicateKeyThrows()
+        {
+            HashMap<int, int> map = new();
+            map.EnsureCapacity(8);
+            map.Add(5, 50);
+            Assert.That(() => map.Add(5, 55), Throws.TypeOf<ArgumentException>());
+            map.Release();
+        }
+
+        [Test]
+        public void ResizeWorksCorrectly()
+        {
+            HashMap<int, int> map = new();
+            map.EnsureCapacity(2);
+            for (int i = 0; i < 100; i++)
+            {
+                map.Add(i, i * 10);
+            }
+            for (int i = 0; i < 100; i++)
+            {
+                Assert.Multiple(() =>
+                {
+                    Assert.That(map.Contains(i), Is.True);
+                    Assert.That(map.TryGetValue(i, out var v), Is.True);
+                    Assert.That(v, Is.EqualTo(i * 10));
+                });
+            }
+            map.Release();
+        }
+
+        [Test]
+        public void RemoveWorksCorrectly()
+        {
+            HashMap<int, int> map = new();
+            map.EnsureCapacity(8);
+            map.Add(1, 100);
+            map.Add(2, 200);
+            Assert.That(map.Contains(1), Is.True);
+            Assert.That(map.Contains(2), Is.True);
+            Assert.That(map.Remove(1), Is.True);
+            Assert.That(map.Contains(1), Is.False);
+            Assert.That(map.Remove(1), Is.False);
+            Assert.That(map.Contains(2), Is.True);
+            Assert.That(map.Remove(2), Is.True);
+            Assert.That(map.Contains(2), Is.False);
+            map.Release();
+        }
+    }
+}

Hexa.NET.Utilities/AlignmentHelper.cs

@@ -0,0 +1,40 @@
+namespace Hexa.NET.Utilities
+{
+    public static class AlignmentHelper
+    {
+        public static ulong AlignUp(ulong size, ulong alignment)
+        {
+            return size + alignment - 1 & ~(alignment - 1);
+        }
+
+        public static uint AlignUp(uint size, uint alignment)
+        {
+            return size + alignment - 1 & ~(alignment - 1);
+        }
+
+        public static long AlignUp(long size, long alignment)
+        {
+            return size + alignment - 1 & ~(alignment - 1);
+        }
+
+        public static int AlignUp(int size, int alignment)
+        {
+            return size + alignment - 1 & ~(alignment - 1);
+        }
+
+        public static ulong AlignDown(ulong size, ulong alignment)
+        {
+            return size & ~(alignment - 1);
+        }
+
+        public static long AlignDown(long size, long alignment)
+        {
+            return size & ~(alignment - 1);
+        }
+
+        public static int AlignDown(int size, int alignment)
+        {
+            return size & ~(alignment - 1);
+        }
+    }
+}