fine-grained locking for huge allocs via hashing

A tiny hash table is used to spread out the huge allocations across more
than one tree. Each tree is associated with a mutex, rather than having
a global huge allocation lock. The default chunk allocator is serial, so
there is currently very little benefit for the main code paths.

Contrived synthetic benchmark to confirm that it works:

    #include <malloc.h>
    #include <pthread.h>
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <sys/sysinfo.h>

    static void *do_work(void *data) {
        void *huge = malloc(8 * 1024 * 1024);
        for (size_t i = 0; i < 1000000; i++) {
            if (malloc_usable_size(huge) != 8 * 1024 * 1024)
                exit(1);
        }
        return data;
    }

    int main(void) {
        int nprocs = get_nprocs();
        pthread_t *threads = malloc(sizeof(pthread_t) * nprocs);
        for (int i = 0; i < nprocs; i++) {
            if (pthread_create(&threads[i], NULL, do_work, NULL))
                return 1;
        }
        for (int i = 0; i < nprocs; i++) {
            if (pthread_join(threads[i], NULL))
                return 1;
        }
    }

On a dual-core Ivy Bridge CPU (4 threads):

Before:

       3283.101936      task-clock (msec)         #    3.556 CPUs utilized
            52,988      context-switches          #    0.016 M/sec

After:

        224.079144      task-clock (msec)         #    3.658 CPUs utilized
                31      context-switches          #    0.138 K/sec

Before: ~1.1s (thousands of futex calls)
After: ~0.08s (only a few futex calls)

Closes #141