Http: Java Routing API Preview

Here's the first batch of the high-level Java server API which already demonstrates a few concepts. Looking at the examples already explains much but I will write a summary as we go along as well.

Implementation is also already available (https://github.com/spray/akka/tree/w/15911-java-routing-dsl-implementation) for everything demonstrated here but omitted here for clarity.

/cc @sirthias 
I like the idea to provide additional `handleWith` overloads that do the extraction before the handler is called. Similar to what you propose it could look like this:

```scala
trait Handler1[T1] {
  def handle(ctx: RequestContext, t1: T1): RouteResult
}
trait Handler2[T1, T2] {
  def handle(ctx: RequestContext, t1: T1, t2: T2): RouteResult
}
def handleWith[T1 <: AnyRef](e1: Extraction[T1], handler: Handler1[T1]): Route
def handleWith[T1 <: AnyRef, T2 <: AnyRef](e1: Extraction[T1], e2: Extraction[T2], handler: Handler2[T1, T2]): Route
```

You would still have to pass in extractions manually:

```scala
path("divide").route(
    parameters(x, y).route(handleWith(x, y,
        (ctx, x, y) ->
            ctx.complete(String.format("%d / %d = %d", x, y, x / y))
    ))
)
```

Having those would also help to prevent a certain kind of request-handling-time bug where an extraction is accessed (`extraction.get(ctx)`) that hasn't been extracted in the route structure. With those `handleWith` directives we can find the bug when the route is created at the start of the program.

Your second proposal is to provide something similar to the Scala version's `Directive[L]` type where L specifies the extractions of a directive. This would remove the need to declare all extractions up front. The big issue with that is that it doesn't compose as nicely as in Scala so that we would have to create lots of boilerplate to make it feasible.