128-bit integers

This patch adds an API for working with unsigned 128-bit integers.  We
currently have functions for addition, subtraction, and comparison.  You
can initialize a `cork_u128` from 32- or 64-bit pieces, and you can
render them as decimal or hex strings.
Use GCC's `__int128` type when available

It might not seem like much, but GCC can produce slightly more efficient
versions of the arithmetic functions for our 128-bit integers if we use
the builtin `__int128` type.  But that's only available in recent
versions of GCC, and more importantly, only on 64-bit platforms.  So we
still need our previous implementation as a fallback for platforms
without the builtin type.
Use cork_u128 in big hash values

Hey look, big hash values are just 128-bit integers.  Let's use our new
`cork_u128` type for those!
Other hash types in cork-hash

The cork-hash utility now takes in a handful of command-line options
that let you choose between the different kinds of hash value that we
can produce: stable (the default, reproducing the previous behavior),
fastest, and big.  Just like the underlying C functions, the final two
are not guaranteed to provide consistent results on different platforms,
or across different versions of libcork.
Merge branch 'feature/int128' into develop

* feature/int128:
  Other hash types in cork-hash
  Use cork_u128 in big hash values
  Use GCC's `__int128` type when available
  128-bit integers
Initialize bitsets to known state

The cork_bitset_new function now ensures that all of the bits in the new
bitset are cleared.  This ensures that the bitset is in a known,
well-defined state to begin with.  There's also a new cork_bitset_clear
function, which lets you reset and reuse a bitset.