Fixed comment text inverting closed/open addressing again.
xmalloc: pre-compute splits of all the possible blocksizes.
xmalloc_freelist_insert(): simpler, faster now that we pre-compute block splits.
xgc_coalesce(): can now handle coalescing that splits into two buckets.
xgc(): use smarter elapsed computation in case we lose the CPU during xgc().
Pre-compute xmalloc() split sizes for blocks to speed-up freelist insertions.

This also makes it trivial to let xgc() handle coalescing of a series of
adjacent blocks whose total size is not one of the natively supported ones.

Also use smarter elapsed time in the xgc() routine to account for the fact
that we may be interrupted and thus the real elapsed time may end up being
much larger than the actual processing time.  A bad estimation needlessly
delays further xgc() invocations.
Added G_GNUC_ALIGNED() to request compiler alignment of structures / fields.
Added default implementation for POSIX offsetof(type, member).
Added definition of POINTER_MAX, the largest pointer value.
Added support for embedded red-black tree handling.
xgc(): redesigned algorithm to allow coalescing of blocks between freelists.
Redesigned the algorithm of xgc() for more comprehensive block coalescing.

The xmalloc() "garbage collector" can now coalesce ranges that span blocks
belonging to any freelist bucket, and is smarter in its coalescing strategy.

This constant background de-fragmentation helps limiting the amount of core
that gets requested (since we have the largest possible blocks available)
and enables earlier freeing of whole ranges (freed pages).

For algorithmic efficiency, embedded red-black trees have been added to the
library, to allow O(log n) insertions, removals and lookups of ranges.
Defined generic data types to reduce the amount of typedefs in data structures.

Removed dependency on Glib for the GTimeVal structure.  Use our own definition
of tm_t and introduced a Windows routine to perform the equivalent of the
gettimeofday() task.
Added support for embedded two-way lists.
Migrated item chaining in hash_list_t from GList to embedded lists.

This saves two pointers per item stored in the data structure.
Use less memory resources to track query MUIDs.

Instead of using both a hash table to store query descriptors and a hash list
to store the MUIDs, use a single structure to hold both and keep them keyed
by MUID within a hash list.

This saves roughly 2 pointers per memorized entry, plus the avoided hash table
overhead.
Redesigned some data structures to save memory.

Introduced expanded two-way lists, which are now used instead of glib's GList
with the hash list to save 2 pointers per item.  There are many usages of
hash lists, some of them storing a vast amount of items (host cache, GUESS
pool, etc...) so the savings add up quickly, especially on 64-bit machines.

Likewise, tracked query MUIDs now use a single hash list instead of combination
of hash list + hash table, drastically reducing the amount of memory used
by the tracking logic.

Also introduced some generic types as part of this change, so that data
containers can share the same types instead of every one defining its own
for iterator callbacks.
Map now uses our hash table implementation.

Also normalized data traversal types in the map and ordered table to avoid
using glib's ones, since we're no longer using glib hash tables.
Highly experimental changes -> bump date.