Use mremap for `mi_realloc` on large objects

Nobody has claimed this yet.

I'd like to be able to use mimalloc to manage my huge objects (arrays or hashmaps which are many gigabytes), not just my small objects. For arrays and hashmaps, we use `realloc` (in turn, `mi_realloc`) to grow the underlying storage. This ensures that, from the array/hashmap perspective, we atomically transition from having an `old_size` object in memory to having an `new_size` object in memory, without ever needing an `old_size+new_size` footprint.

Sadly, mimalloc's internal implementation breaks this invariant. It is internally implemented by allocating a new object, copying, and deallocating the old object.

I'd like the following extension to mimalloc:
* pick some `MMAP_THRESHOLD`, perhaps MMAP_THRESHOLD=64MiB
* all objects `>=MMAP_THRESHOLD` are allocated by a (non-cached) syscall to `mmap` (likely with appropriate HUGEPAGE flags)
* for `mi_realloc` where both the before and after size are `>=MMAP_THRESHOLD`, it is implemented by a (non-cached) syscall to `mremap`

Start at mi_realloc and trace how large allocations are currently handled. Read the platform’s mmap and mremap interfaces and determine how the proposed MMAP_THRESHOLD, non-cached mappings, and huge-page flags would fit the allocator. Done means large allocations use mmap and eligible reallocations preserve the old-plus-new footprint invariant through mremap.

Written by the indexing model from the issue text.