Implemented injectable router

* Replaced Routes.setPrefix with Routes.withPrefix
* Created RoutesPrefix so that there was no direct dependency from the reverse router to the forwards router
* Applied RoutesPrefix object change to old static router
* Created new injected forwards router
* Implemented abstraction in the sbt plugin that allows selecting a routes generator
* Copied existing routes-compilation scripted test to new injected-routes-compilation scripted test that uses injected routers
For example, what's the difference between your proposal, and doing this:

```scala
trait RoutesFactory {
  def withPrefix(prefix: String): Router.Routes
}

class Routes(...deps..., prefix: String) extends Router.Routes with RoutesFactory {
  @Inject
  def this(...deps...) = new this(...deps..., "/")
  def withPrefix(prefix: String) = new Routes(...deps..., prefix)
  ...
}
```

The reason why separating them would not work well is because then your routes file will have to point to things of type routes factory, rather than things of type `Routes`:

```
->  /foo      foo.MyRoutesFactory
```

Now we can name them routes in the code we generate, but that's a bit weird... if I manually implement a router, and I'm implementing a class called `RoutesFactory`, naming conventions say I should call it `MyRoutesFactory`.

As for the static routes, perhaps we can make it not an object - it had to be an object before because the reverse routers depended on it.  But now we've moved that dependency to a `RoutesPrefix` object, they can be ordinary classes.