Beginnings of a class-based services interface

Uses the eSpeak service as a test case -- the new interface would allow
for the removal of boilerplate code, but will more importantly allow
services to begin advertising other options (e.g. amplitude, speed, gap,
pitch) that they have available.
Basic initialization for a service router

Once completed, this object can takeover for the initialization, recall,
and messaging of the various services.
Services interface simplification

Merges record() and play() together, with the aim that all services will
begin to use the Anki sound interface for queueing and non-blocking
playback.

Simplifies exception handling so that initialization routines may throw
an exception without bothering the user.
No more caching or subprocessing in configuration

With the new services structure, caching will become mandatory and
subprocessing will become unnecessary.
Implement eSpeak in new interface

This also introduces various path and transcoding functions on the base
class.
Add support for Ekho engine

This also makes some minor adjustments to eSpeak for consistency only.
Eliminate code member in Service classes

This is not ever used for anything, and shouldn't ever need to be.
Introduce service traits

These will be usable by the rest of the application to determine what
kinds of things a particular service does or needs (e.g. transcoding of
audio files, downloading files from the Internet).
Implement Google service using new interface

This also introduces a new net_download() method on the base class for
performing downloads.
Implement SAPI 5 support using new interface

These changes obsolete some of the shared path and utility code.
Port Mac OS X Say over to new services interface

With this one, all services have been ported.
Remove dead modules and provide migration script

Takes these out of the tree entirely and provides Anki a bit of script
that can be run at startup to pull them out of the tree if the user is
upgrading.
Interface cleanup

Removes unneeded modules, constants, lambdas, and other such things.
Converts what used to be class methods on the Service base to instant
methods so a class can behave differently based on its state.
Begin router implementation

Introduces get_services() and get_options(), which will both be usable
for building service forms in the UI.
Lazy loading and memoization for services

Improves performance by only loading a service or querying its data when
needed, and memoizing the result into the router instance.
Basic playback implemented in router

This still needs some additional validation and normalization work.
Custom normalization and validation for services

With these additions, services can now specify how user input should be
normalized (e.g. for parsing voices with more leniency) and how user
input should be validated (e.g. by allowing ranged values to work even
if the value the user specified isn't in one of our nice dropdown
lists).
Add text phrase normalization to router

This is done by passing in another lambda, and it can clean up HTML,
sound tags, and excess whitespace.
Remove memoization for service lists

This is so quick to be generated that memoization is not necessary or
worthwhile.
Wire on-the-fly playback to new router

Connects the existing on-the-fly code to go through the new router's
play() method, also fixing the options code to correctly remove keys
that are not part of the options set.