Methods to dynamically allocate cork_ring_buffer

This patch includes two new methods, `cork_ring_buffer_new()` and
`cork_ring_buffer_free()`, which allocates a ring buffer on the
heap.
Fix compiler error on 32-bit platforms

Our 32-bit implementation of the big hash functions had a compiler
error.  This should (hopefully) fix them.
Delete known entry from hash table

The new `cork_hash_table_delete_entry` function lets you delete an entry
from hash table more efficiently.  You pass in a `cork_hash_table_entry`
instance, instead of a key value.  This means that we don't have to
search through the hash table for the value to delete; the entry
instance acts as a pointer to the specific entry that we want to delete.
Don't ignore initial hash table size

How about we actually pay attention to the `initial_size` parameter and
allocate that many buckets?
Description of executable programs

I need to print out a nice string representation of a `cork_exec`
instance basically all the damn time, so let's make a helper function
for that.
Merge branch 'feature/ring-buffer-heaped' into develop

* feature/ring-buffer-heaped:
  Methods to dynamically allocate cork_ring_buffer
Updated PowerPC detection macros

The autodetection logic was missing some of the macros listed at [1]
that can be used to detect a PowerPC machine.  This should get them all.

[1] http://sourceforge.net/p/predef/wiki/Architectures/
Unique identifiers

The new `cork_unique_id` type represents a unique identifier that is
visible at compile-time.  You can use these identifiers as keys for
extensible points in a plugin system, for instance; the identifiers
themselves will be unique within a given execution of the program, and
they'll each have a name associated with them to help produce useful
debug and error messages.
Prefixing error messages

You can use the new `cork_error_prefix` function to prepend some
additional text to an existing error message.

This patch also updates the internal implementation to clean up after
itself better.  Before, we would grab a thread-local `cork_error`
instance for each thread, but didn't clean up those instances.  Now, we
maintain a (thread-safe) list of all of the `cork_error` instances that
have been allocated, and register a (process-level) cleanup function
that cleans all of them up.
Access stdin of subprocesses

You can now access the stdin stream of any `cork_subprocess` instance
that you create.  Access is provided via a `cork_stream_consumer`
instance; any data that you write into that stream consumer is sent to
the subprocess's stdin.  We don't do any buffering, or worry in any way
about the buffering of the underlying pipe — you must handle this
yourself if there is any kind of complicated orchestration needed by the
subprocess that you're calling.
Subsecond timestamp format specifier

This patch updates the timestamp formatting functions so that we don't
use the builtin ``strftime`` under the covers.  This limits the number
of standard format specifiers that we support, but we can add more of
them back in as they're needed.  Importantly, this lets us add a new
specifier (%[width]f), not covered by ``strftime``, to include the
fractional seconds portion of the timestamp.

I'm also taking this opportunity to change the signature of the
formatting functions; the result is now rendered into a `cork_buffer`,
instead of into a fixed-size buffer.
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.