Modules installer

This is a simple modules installer (can't handle multiple files, or requirements yet)

It connects to http://jaspermoduleshub.herokuapp.com/

I added a `walk_packages` on `brain.py` so that modules can be installed in subfolders.
Well, the point is that OOP only makes sense if you actually have a state/attributes to save.

If you look at the [PocketsphinxSTT class](https://github.com/jasperproject/jasper-client/blob/master/client/stt.py), it's a method that only has one public method (Let's not look at the inheritance stuff right now). But (and that is important) it also holds the Pocketsphinx decoder instance and saves the languagemodel/dictionary paths.
If we wrote this as a pure function, we'd have to reinitalize the pocketsphinx decoder and pass the languagemodel/dictionary paths as parameter every time we transcribed something. Therefore, it's very useful that we implemented `PocketsphinxSTT` as a class rather than some kind of `pocketsphinx_stt_transcribe(languagemodel, dictionary, wavfile)` function.

But, if we don't save states (which is IMHO the case here) we really don't need OOP. I recommend reading the [section about object oriented programming](http://docs.python-guide.org/en/latest/writing/structure/#object-oriented-programming) in the Hitchhiker's Guide to Python.

*We currently have 3 possibilities on the table:*

**My suggestion** was to have a single module installer object that holds the install locations and then can be used to install multiple modules into these locations. Otherwise, you'd need to pass the install locations every time you want to install a module (at least if you want to make stuff configurable).
Therefore, you could use it like this:
1. Initalize ModuleInstaller with locations
2. Call `instance.install('a')` to install module `a` to the locations passed to `__init__()`
3. Call `instance.install('b')` to install module `b` to the locations passed to `__init__()`
[...]
N. Throw away the instance

**The current implementation** has to be used like this:
1. Initialize ModuleInstaller with module name `a`
2. Call `instance.install()` to install module `a`
3. Throw away instance
You can leave out step 2, but then you can also leave out 1 and 3, because these steps are just a waste of resources. Although you're saving the module name in `__init__()`, it's not really neccessary, because you'll usually call `install()` right after `__init__()` and then throw away the object.

I can't really see a difference to **the non-OOP approach**, except that it's simpler to understand and probably shorter:
1. Call module function `install('a')` to install module `a`

To me, the current implementation looks like this:
```Python
# instead of doing this:
def add(a,b,):
    return a+b

# we're doing this:
class AddingClass(object):
    def __init__(self, a, b)
        self.a = a
        self.b = b
    def add():
        return self.a + self.b
```