Fixed iteration order in hash tables

When iterating through a hash table (whether explicitly via a
`cork_hash_table_iterator`, or autoatically via `cork_hash_table_map`),
we now guarantee that the elements will be processed in the same order
that they were added to the hash table.

To support this, we need an additional doubly-linked list to keep track
of the insertion order.  This requires adding fields to the
`cork_hash_table` type.  So, I'm taking this opportunity to make that
type completely opaque.  That means that this will be a
backwards-incompatible change; all code that still embeds a copy of
`cork_hash_table`, and uses `cork_hash_table_init` to initialize it,
will need to be updated to use `cork_hash_table_new` instead.

Finally, at the same time, I've made a couple of other
backwards-incompatible changes to make the hash table API more
consistent with our current best practices.  First, the hashing and
comparison functions now take in a `user_data` parameter, just like any
other callback.  Second, the signature of the `cork_hash_table_map`, and
its `map` callback, have been reordered so that `user_data` comes first.
Free keys and values in hash tables

You can now provide two optional callbacks (`free_key` and `free_value`)
that will cause your hash table to take ownership of the keys and values
that it contains.  The keys and/or values will be automatically freed
(using the provided callbacks) when entries are deleted, and when the
hash table itself is destroyed.
Explicit hash values

This patch adds new `_hash` variants for each of the functions for
interacting with hash tables.  These new variants let you provide a hash
value explicitly, as an extra function parameter, instead of making the
hash table call its `hash` callback to generate the hash value.  This
can be useful if you've already calculated and cached the hash value
somewhere.
Pretty-printing into a cork_buffer

This patch adds several functions for pretty-printing binary content
into a cork_buffer.
Additional doubly-linked list functions

This patch adds a few new functions for working with doubly-linked
lists.  The functions for adding single elements to a list have more
descriptive names, and there are now functions for moving an entire list
of elements into some other list (in constant time).

Additionally, the function for mapping through a list has replaced with
a function for “visiting” each element.  This is mainly to make the
function signatures more consistent with our other callback-based
functionality — you can abort the iteration with a non-zero result code,
and the `user_data` parameter is first.

Lastly, there are now helper macros for iterating through a list
yourself, rather than using a visitor callback.  See the documentation
or test case on how to use it.
Make buffer appending more efficient

We make cork_buffer_append_vprintf more efficient by not relying on
vsnprintf to determine the size of the format string.  Instead, we
call vsnprintf directly on the current buffer.  If it fails, we add
more space to the buffer and repeat.  The second call is guaranteed
to succeed since the call to cork_buffer_ensure_size_int guarantees
the requested space will be available upon return.