Add POD structure and allow types to have custom prefixes.

### General Lookup Path

* `podModulePrefix/name/type`
* `modulePrefix/type` (if the format is `type:main`)
* `typePrefix/pluralizedtype/name`
* `modulePrefix/pluralizedType/name`

So given that I have the following resolver:

```javascript 
Resolver.create({
  namespace: {
    modulePrefix: 'app',
    podModulePrefix: 'app/pods',
    petPrefix: 'animals'
  }
});
```

The lookups would be like the following:

* `fruit:orange`
  * `app/pods/orange/fruit`
  * `app/fruits/orange`
* `pet:dog`
  * `app/pods/dog/pet`
  * `animals/pets/dog`
* `furniture:main`
  * `app/pods/main/furniture`
  * `app/furniture`
  * `app/furnitures/main`

#### POD Structure

When given an item to lookup (say `resolve('controller:foo')`), the POD structure would dictate that you would actually be looking up a module at `podPrefix/foo/controller`. This format is given the first (and primary) shot at finding a module.

For example, given a `podModulePrefix` of `app/pods` you would have the following:

```
* `route:posts`            -> `app/pods/posts/route`
* `template:posts`         -> `app/pods/posts/template`
* `controller:posts`       -> `app/pods/posts/controller`
* `route:posts/index`      -> `app/pods/posts/index/route`
* `template:posts/index`   -> `app/pods/posts/index/template`
* `controller:posts/index` -> `app/pods/posts/index/controller`
* `route:posts/edit`       -> `app/pods/post/edit/route`
* `template:posts/edit`    -> `app/pods/post/edit/template`
* `controller:posts/edit`  -> `app/pods/post/edit/controller`
* `route:posts/show`       -> `app/pods/posts/show/route`
* `template:posts/show`    -> `app/pods/posts/show/template`
* `controller:posts/show`  -> `app/pods/posts/show/controller`
```

Note that without a `podModulePrefix` set these would all default to the `modulePrefix` (basically replace `app/pods` in the above examples with `app`).

#### Custom Type Prefixes

If a module was not found via the POD lookup structure, look for a custom `typePrefix` value on the namespace.

This allows us to customize where each type is looked up.

For example if I have the following types:

* human
* dog
* cat
* couch

And I wanted them to resolve like:

* human named 'Rob' - 'humans/rob'
* dog named 'Lucy' - 'pets/dogs/lucy'
* cat named 'Kisses' - 'pets/cats/kisses'
* couch named 'Ethel' - 'furniture/couches/ethel'
* EVERYTHING else under 'app/'

I could do the following:

```javascript 
Resolver.create({
  namespace: {
    modulePrefix: 'app',
    dogPrefix: 'pets',
    humanPrefix: 'humans',
    catPrefix: 'pets'
    couchPrefix: 'furniture'
  }
});
```

(Please note all names are real, no making fun...)

-----

This builds off of #14 which adds some real tests.