Simpler error API

This patch simplifies the libcork error API.  Before, we followed glib's
GError API, where there were separate “classes” and “codes” for each
custom error condition.  The class was meant to identify the library
that the custom error belongs to, and the code only had to be unique
within each class.  GError creates error class values at runtime, using
its GQuark mechanism.  We use hashes of unique strings as error classes.
Error codes were then defined using a simple enum.

This is more cumbersome than it needs to be.  With this new patch, we no
longer have error classes at all.  Individual error codes are now hash
values, usually of the name of the error code's macro.  (I.e., the
value of the `CORK_PARSE_ERROR` error code is the hash of the string
`"CORK_PARSE_ERROR"`.)  This new design also lets us use the existing,
predefined, well-known POSIX `errno` values as error codes directly,
which makes it easier to integrate code that uses the POSIX error
reporting facilities and libcork's error API.
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.
Include thread linker flags in pkgconfig file

On Debian, it looks like we need to tell any library that links with
libcork to also link with the threading library that libcork was
configured to use.  We can pass that information along using the
pkgconfig file.
Merge branch 'feature/thread-libs' into develop

* feature/thread-libs:
  Include thread linker flags in pkgconfig file
Remove cork_thread_body

Part of a larger effort to move away from embedded structs for these
kinds of OO-like types.  (We want to be able to make the types
completely opaque, so that we can add to them at will without breaking
ABI compatibility.)
Merge branch 'feature/thread-body' into develop

* feature/thread-body:
  Remove cork_thread_body
Bump soversion for 0.13.0
Merge branch 'release/0.13.0' into develop

* release/0.13.0:
  Bump soversion for 0.13.0
Start man page migration