RFC: phased router [do not merge]

A prototype implementation of of a phased router - see #739.

**Usage**

```js
// called inside "routes" phase
app.use('/foo', function(req, res, next) { / * ...  */ });

// called amongst the first middleware
app.phase('init').use(compress());

// called after all routes were handled
app.phase('files').use(loopback.static('./public'));

// install a "before" handler
app.phase('init').before(serveFavicon(loopback.faviconFile));

// create a route invoked before "regular" routes
// note that `.after` and `.before` cannot be used for routes yet
app.phase('init').post('/foo', function(req, res) { /* ... */ });
```

**Todo**

 - API for registering new phases and specifying their order
 - Add more built-in phases (probably in loopback to keep the phased router less opinionated)
 - Consider renaming `error` phase to `end` or `final`
 - Move server-specific code from `lib/application.js` to a standalone file
 - Contribute express enhancement allowing people to configure their own Router implementation to be used as the default router, without the need to copy & past `app.lazyrouter` function: https://github.com/strongloop/express/pull/2431
 - Fix `undefined phase` in `PhaseList.run` - see https://github.com/strongloop/loopback-phase/pull/2
 - Write a unit-test to verify that router properties like `caseSensitive` are correctly forwarded by `DecoratedRouter`
 - Improve loopback-phase to support generic `Phase` implementations (any object with `id` and `run` can be used as a phase)
 - Implement customization hooks in `PhaseList.run`
 - Implement `PhaseList.get(name)` that throws a helpful error when the phase was not found

/to @raymondfeng @ritch please review, ideally by EOD. Tomorrow my time, I'll start moving the code to a new module `strong-router` and work on the missing items outlined above.
Not really.

1. AFAIK `util.inherits` works for objects created via `new`. The router instances are functions, they use different mechanism.

2. With `util.inherits`, if you want to override a method and call the base class from your impl, you have to use `apply` or `call`, because you need to specify a different `this` object:

  ```js
  Child.prototype.method = function() {
     Base.prototype.method.apply(this, arguments);
  }
  ```

  `DecoratedRouter` allows you to call methods without bind, because `this._super` and `this` are sharing the same set of properties.

  ```js
  Decorated.prototype.method = function() {
    this._super.method();
  }
  ```

However, there is one thing that does not work:

```js
Base.foo = function() {
  this.bar();
}

Decorated.foo = function() {
  // do something
  this._super.foo();
}

var d = new Decorated();
d.bar();
// calls Base.foo, not Decorated.foo
```

I'll give this some more though tomorrow to see if I am able to come up with a better solution.