feat! Mimalloc as the default allocator (#434)

This change integrates mimalloc as the default memory allocator for Regorus,
delivering significant performance improvements across all evaluation modes
and language bindings.

Technical Implementation:
- Build mimalloc in vendored mode from C sources (following QSharp approach)
- Implement GlobalAlloc trait for seamless Rust integration
- Add optional 'mimalloc' feature flag for conditional compilation
- Add comprehensive ACI benchmarks to measure evaluation performance

Performance Impact:

Rust Engine Evaluation:
- Single-threaded: ~29% improvement (423 vs 328 Kelem/s)
- Multi-threaded: Better scaling with reduced thread contention
- Fresh engines: ~24% improvement (56 vs 45 Kelem/s)

Rust Compiled Policy Evaluation:
- Single-threaded: ~41% improvement (426 vs 303 Kelem/s)
- Multi-threaded: Improved allocation efficiency under contention
- Fresh compilation: ~26% improvement (53 vs 42 Kelem/s)

C# FFI Bindings:
- Engine evaluation: ~27% improvement (279 vs 219 Kelem/s)
- Compiled policies: ~29% improvement (273 vs 211 Kelem/s)
- Better threading characteristics through improved underlying allocation

Key Benefits:
- Reduced allocation-related contention in multi-threaded scenarios
- More consistent performance across different thread counts
- Improved memory allocation efficiency for both native Rust and FFI workloads
- Better scaling characteristics for production deployments

The mimalloc integration provides substantial performance gains while
maintaining full compatibility with existing code through feature flags.

Reference: QSharp allocator implementation
(https://github.com/microsoft/qsharp/tree/main/source/allocator)

Fixes #297

Signed-off-by: Anand Krishnamoorthi <anakrish@microsoft.com>

mimalloc/src/lib.rs

@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#[cfg(not(any(target_family = "wasm")))]
+pub mod mimalloc;
+
+/// Declare a global allocator if the platform supports it.
+#[macro_export]
+macro_rules! assign_global {
+    () => {
+        #[cfg(not(any(target_family = "wasm")))]
+        #[global_allocator]
+        static GLOBAL: mimalloc::mimalloc::Mimalloc = mimalloc::mimalloc::Mimalloc;
+    };
+}

mimalloc/src/mimalloc.rs

@@ -0,0 +1,79 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use core::alloc::{GlobalAlloc, Layout};
+use core::ffi::c_void;
+
+use mimalloc_sys::{mi_free, mi_malloc_aligned, mi_realloc_aligned, mi_zalloc_aligned};
+
+pub struct Mimalloc;
+
+unsafe impl GlobalAlloc for Mimalloc {
+    #[inline]
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        debug_assert!(layout.align() < mimalloc_sys::MI_ALIGNMENT_MAX);
+        mi_malloc_aligned(layout.size(), layout.align()).cast::<u8>()
+    }
+
+    #[inline]
+    unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
+        mi_free(ptr.cast::<c_void>());
+    }
+
+    #[inline]
+    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+        debug_assert!(layout.align() < mimalloc_sys::MI_ALIGNMENT_MAX);
+        mi_zalloc_aligned(layout.size(), layout.align()).cast::<u8>()
+    }
+
+    #[inline]
+    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+        debug_assert!(layout.align() < mimalloc_sys::MI_ALIGNMENT_MAX);
+        mi_realloc_aligned(ptr.cast::<c_void>(), new_size, layout.align()).cast::<u8>()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::error::Error;
+
+    #[test]
+    fn memory_can_be_allocated_and_freed() -> Result<(), Box<dyn Error>> {
+        let layout = Layout::from_size_align(8, 8)?;
+        let alloc = Mimalloc;
+
+        unsafe {
+            let ptr = alloc.alloc(layout);
+            assert!(!ptr.cast::<c_void>().is_null());
+            alloc.dealloc(ptr, layout);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn memory_can_be_alloc_zeroed_and_freed() -> Result<(), Box<dyn Error>> {
+        let layout = Layout::from_size_align(8, 8)?;
+        let alloc = Mimalloc;
+
+        unsafe {
+            let ptr = alloc.alloc_zeroed(layout);
+            assert!(!ptr.cast::<c_void>().is_null());
+            alloc.dealloc(ptr, layout);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn large_chunks_of_memory_can_be_allocated_and_freed() -> Result<(), Box<dyn Error>> {
+        let layout = Layout::from_size_align(2 * 1024 * 1024 * 1024, 8)?;
+        let alloc = Mimalloc;
+
+        unsafe {
+            let ptr = alloc.alloc(layout);
+            assert!(!ptr.cast::<c_void>().is_null());
+            alloc.dealloc(ptr, layout);
+        }
+        Ok(())
+    }
+}