Better /bin/sh compatibility in run-test

I guess the run-test script had an if test that used a bash extension.
This makes it work with dash, too, and presumably any other /bin/sh
clone.
Only configure @VARS in pkg-config file
Update Sphinx configuration to work with Python 3
Portable thread IDs

This patch updates the `cork_thread_id` type to have a portable
definition that's consistent across all platforms.  That means that we
must assign the thread IDs ourselves, since we can't rely on
`pthread_get_self` (or its equivalent) to get the thread ID.

We assign IDs by maintaining a thread-local descriptor structure.
`cork_tls` initializes this structure with 0 bytes when it's first
allocated or accessed, which corresponds to the "no thread ID assigned"
value for our new `cork_thread_id` type.  This lets us detect that we
haven't assigned an ID to the current thread yet, increment our thread
ID counter, and return that newly incremented value.
Separate recursive and non-recursive `cork_once`

The cork_once macro has now been split into two variants.  The existing
`cork_once` macro has been reverted back to not allow itself to be
called from within a recursive function; if you do this, it will
deadlock.  It's a slightly faster implementation, though, and more
importantly, on systems without the `__thread` storage class, we have to
use `cork_once` to implement the `cork_thread_get_id` function.  And
the recursive variant of `cork_once` needs to know the current thread's
ID.  This mutual dependency gave us an infinite loop on Mac OS X for the
`cork_thread_get_id` function.

Now we implement `cork_thread_get_id` with the non-recursive variant,
which doesn't require access to the thread ID, breaking the mutual
dependency.
Merge branch 'feature/thread-id' into develop

* feature/thread-id:
  Separate recursive and non-recursive `cork_once`
  Portable thread IDs
[docs] Changed formatting for h3 and lower
Macro versions of several IP address functions

Several of the IP address functions have been turned into macros, to
help inline their simple definitions when they're used.  The function
versions are still available, but with a trailing underscore in their
name.  Note that this change will introduce an ABI (but not API)
incompatibility in the next release.
Power-of-2 number of hash table bins

We now ensure that the number of hash table bins is a power of 2.
Before, we were ensuring that it was a prime number.  This was useful
for old-school hash functions, which only provided uniform distribution
modulo a prime number of bins.  We're using a nicer hash function that
is uniform regardless, and switching to a power-of-2 number of bins lets
us use a tasty fast logical AND instead of a modulo operator.
Use memory pool in hash table

This is much faster for allocating the entries that are stored in the
hash table bins.  However, it introduces an ABI incompatibility, since
the `cork_hash_table` type has an additional field in it.
“Stable” and “big” hash values

This patch introduces three new functions for calculating hash values.
A “stable” hash is guaranteed to be the same regardless of which
platform the code is running on.  It's also guaranteed to be consistent
across libcork versions.  A “big” hash value is drawn from a much larger
space of possible hashes (128 bits vs 32), giving you a correspondingly
smaller chance of hash collisions.  We still use MurmurHash3 as the
implementation of all three hash variants.
Merge branch 'feature/hash-mempool' into develop

* feature/hash-mempool:
  Use memory pool in hash table
Merge branch 'feature/power-of-2-bins' into develop

* feature/power-of-2-bins:
  Power-of-2 number of hash table bins
Use cram for command-line tests

We know use cram [1] to run any command-line tests in our C projects.
It provides the same functionality as our cobbled-together `run-test`
and `train` scripts, with a nicer interface.

[1] https://bitheap.org/cram/
Built-in file consumers and producers

This patch adds built-in stream producers and consumers that work with
files and file descriptors.  The file producers read from a file, and
send the data into some other stream consumer.  The file consumers
append any data received into a file.
Rename license file to COPYING

That seems to be the standard.
Merge remote-tracking branch 'templates/c-template' into feature/cram-tests

* templates/c-template:
  Use cram for command-line tests
  [docs] Changed formatting for h3 and lower
  Update Sphinx configuration to work with Python 3
  Only configure @VARS in pkg-config file
  Better /bin/sh compatibility in run-test

Conflicts:
	src/CMakeLists.txt
	tests/run-test
Update command-line test cases to use cram
Merge branch 'feature/cram-tests' into develop

* feature/cram-tests:
  Update command-line test cases to use cram
  Use cram for command-line tests
  [docs] Changed formatting for h3 and lower
  Update Sphinx configuration to work with Python 3
  Only configure @VARS in pkg-config file
  Better /bin/sh compatibility in run-test
Basic subprocess support

This patch adds a basic interface for starting subprocesses and
executing programs within them.  It's meant to be a C equivalent of
Python's `subprocess` module.  The API currently includes the ability to
capture stdout and stderr, and to propagate any termination signals, but
we haven't implemented that yet.