WIP: Use threads instead of gevent cause it is native
Implementing my own pool to execute the workers just once in the start
Removing a random assert
Fixing a couple tests
Removing old stuff
Adding a very silly signal implementation
Adding a treestore to be used inside of the maestro
Adding the `TreeStore.from_path` method

This method simply retrieves a node based on its path in the
tree.
First steps towards a maestro component

This component will maintain the reference to the package dependency
graph. Every time a new package is requested, the `file_package` method
will file that package under its dependency, building a tree;

In the next few commits, we will introduce the concept of closing a
node, which is just the same as saying that the node we are talking
about had all its dependencies collected;

The exit case from the recursion of download -> find_deps -> download
will be finding all the packages that have no dependencies.
Removing a method we currently do not need righ now
Add version granularity to the maestro's mapping

Now the data structure that keeps the requested packages is aware of
multiple versions of the same package requested as dependency by
different packages.
All `Service`s will become signal emitters

The class `Service` now inherits from `SignalEmitter`, so we'll be able
to interact with other services maintaining them decoupled;

A bunch of random changes were made in this commit to achieve that (or
not). Here's the list:

 * The `Service.handle` method has its signature changed to:
   >>> handle(requester, package, sender_data)

 * The `Curdling` class was renamed to `Curdler`;

 * The property `Service.name` was moved to `SignalEmitter`;

 * Both methods `Service.{start,queue}` now return `self` (chain);

 * The constructor of the `Uploader` class was finally updated so now it
   looks like all the other services;
Change version schema to `legacy` in the Downloader

Crazy version schemas (like pytz) are just not supported by the
scheme we were using (`adaptive`).
Add the dependency finder

This component basically iterates over the list of dependencies
found in the wheel package received by the component and emit
the `dependency_found` signal.
Connecting components to our maestro

Our `download > build > find deps` flow is now managed by the maestro
notified by new dependencies and nodes with no dependencies through our
signal system.
Who said we needed a tree in the first place?
Maestro.mark_built() now takes the package path

Taking this new parameter saves us a couple extra IO calls to find the
file in the index again and just looks like a better usage of the
communication system we established between our components.
Update version syntax in test_index_get()
Index.get() should be case-insensitive
Start the Installer after finding all the required packages

After making sure that we've got all the dependencies we were looking
for, we start the installer service and queue all the packages the
maestro collected along the way;

The method `request_install` looks saner now and actually uses the cache
before starting any downloads. Trying to find wheels then tarballs.