Refactor Storage Manager

# General
+ convert various `=>`s to `->`s.  Saves constructor bloating and should reduce file size.
+ moving a lot of stuff around in various places to organize the code a little more

# Builders
+ stopped eval'ing the builders, not sure why we were doing that..

# Demo Models
+ switched to `urlRoot` instead of `url`

# Spec Helper
+ added shared behaviors (`ModelLoader` and `CollectionLoader` use these to make sure the behavior isn't broken)

# Storage Manager
+ all of the loading functionality is essentially pulled out of this and delegated to a `CollectionLoader` or `ModelLoader` via `#loadObject`
+ move `wrapObjects` to `Brainstem.Utils` from the StorageManager

## loadModel
+ now requires an ID as the second arguments (before it would just.. not work and silently [sometimes] fail)
+ now uses the shared `loadObject`
+ now immediately returns a loader (which acts as a promise) instead of a model
  + you can call `getModel` on this if you need the model but otherwise the promise (and success callback) will be resolved/called with the model.
+ model only requests are done through a show route without the `&only=1` filter.

## loadCollection
+ now uses the shared `loadObject`

## Expectations

### handleExpectations
+ takes a loader now and not `[name, collection, options]`
  + uses the `loader.originalOptions` to compare them against the expectation

# LoadingMixin
  + removed old `whenLoaded` function that was never used.

# AbstractLoader

handles most of the recursive loading.  individual loaders specify the behavior that they need (updating objects, updating storage manager, etc)

# ModelLoader

implements model specific loading behavior (`internalObject == externalObject`)

# CollectionLoader

implements collection specific loading behavior (loading is done via an internalObject that then updates an externalObject when everything is loaded).  The promise/callback is resolved with the externalObject which is a slice of what is in the storageManager.

# Brainstem.Model
  + models no mix in the `LoadingMixin`.
  + models that are saved / fetched are added to the storage manager instead of a new instance being created.

# Brainstem.Expectation
+ recursive
  + by default recursive is false which means all associations are done at the top level using the stub (.associated) so we don't need to make extra loaders and "requests" in an expectation.
  + however in some cases (and if you want to test how the real world behaves [nested includes]) you're going to want to stub out multiple "requests" and the recursive option on the stub needs set to true

## recordRequest
+ takes a loader now and passes that loader around instead of collection + callOptions (which are stored on the loader)

## optionsMatch
+ fixed some bugs that ended up occurring with the other changes (storing them on the loader).  Now compares includes wrapped (via `wrapObjects`).

# Todos / Notes
+ `Brainstem.Expectation#handleRequest` could potentially defer to `AbstractLoader#_onServerLoadSuccess` or `_updateStorageManagerFromResponse` instead of putting it in the storage manager itself? maybe?
+ ~~cleanup `Brainstem.Expectation#optionsMatch` (could skip the `wrapObjects` if wildcard, would perform better)~~