Promise

Added a Promise<T> template, which encapsulates the idea of a promised, future return value, for use with asynchronous functions going forward.

In contrast to the built-in std::future and std::promise, provides a Then function, which attaches a function to received the promised value.  The Then function, in turn, returns yet another Promise<T>, for the result of the specified function.
Thread Pool Rewrite

Rewrote the ThreadPool class entirely.  It now uses a helper thread for scheduling delayed callbacks, which results in much cleaner code and fewer spurious wakeups of worker threads.

The code separates responsibilities much better, and as a result is much cleaner.

Returns promises rather than ThreadPoolHandle objects, with the latter having been axed entirely.
SafeInt Helpers

Wrote two helper template functions for SafeInt<T> which will make code which converts back-and-forth between integer types (mostly for C API interop) much cleaner going forward.
Socket Pair

Wrote a SocketPair class which closely resembles the functionality of the POSIX socketpair function.  Also works on Windows.

Will be helpful in reimplementing the libcurl wrapper, which uses ugly/messy polling for lack of a master-to-slave means of waking up select.
libc-ares Wrapper

Added an asynchronous libc-ares wrapper, which adds libc-ares as a dependency (updated README.md to reflect this).

Supports asynchronous resolution of A, AAAA, MX, NS, TXT, PTR, SRV, and SOA records.  Also includes a method which simultaneously performs A and AAAA lookups, and aggregates the results.
libcurl Wrapper Rewrite

This has been coming for a while (since the original wrapper was written) as the original was a total mess.

The new wrapper:

Uses the SocketPair class to be more responsive.  Due to the lack -- previously -- of a good way to wake up the worker while it was sleeping on select (since Windows doesn't have socketpair natively and libcurl doesn't allow for IOCP to be integrated easily), the worker just set an arbitrary timeout and was completely unresponsive while waiting for socket events.  Newly-added easy handles were liable to sit untouched, and a shutdown was liable to block unnecessarily.  This has all been rectified.

Handles all HTTP requests it's capable of handling (limited to GET, HEAD, and POST at the moment) through a single method.  This method takes an HTTPRequest object, which carries all information about the request.  This allows for much cleaner code to be built on top of the handler, as code that issues a variety of HTTP requests can easily build shared code to handle/dispatch them.

Uses promises.  Making a request returns to the caller a promise of an HTTPResponse object, which contains all data the handler parses from the server.  Unlike the old handler this leaves the choice of how to proceed -- block or continuation -- to the caller, increasing caller flexibility/ease of use.  The fact that promises pass exceptions through also means that the handler communicates failures in the proper C++ manner -- by throwing -- which makes its API much less confusing/easier to consume.

Is much cleaner.  The code separates responsibilities much better, and is much cleaner/more readable as a result.

Properly handles alternative character encodings in the response.  Previously the handler made the assumption that all text was UTF-8.  The handler is now capable of properly parsing the HTTP Content-Type header and determining which decoder to use based on that (falling back to UTF-8).  Decoding is now done lazily, so rather than decoding the response as it comes in, raw bytes are returned in the HTTPResponse object, which the caller may lazily have decoded (by a method on the HTTPResponse class).  This increases caller flexibility, as the caller has access to the raw bytes of the response (in case -- for example -- something other than text is being returned).
Yggdrasil Rewrite

Completely rewrote the Yggdrasil client to use the newly-rewritten HTTPHandler and to use Promise<T> for asynchronous return values.

The new client has a much cleaner API, especially with respect to error reporting.  Rather than passing through variants whose engaged type specified whether the request succeeded or failed, the promise exception throwing mechanism is used to throw the appropriate exception if the request fails.  This makes the API much easier to consume, and is also in line with good C++ style/form.
Remove Authentication Module Debug

The Yggdrasil client does not have debug hooks yet, therefore the relevant code in the authentication module has been temporarily removed.
Vanilla Authentication Update

Updated the vanilla authentication module to consume the newly-rewritten Yggdrasil client API.

Also added the vanilla authentication module to the list of modules to be build by Make.  It was either mistakenly removed or never added in the first place.
Server Update

As the rewritten thread pool now accepts a panic callback which takes a std::exception_ptr argument (which enables robust panic logging), a callback of that type is now passed to it by the server container.
Merge branch 'async_overhaul'

Everything builds again, and the asynchronous utilities in mcpp.dll have been rewritten/-factored to be much cleaner/more usable.