!htc #15726: Akka HTTP with the new DSL

/cc @jrudolph @sirthias 

TODO:
 - [X] Port http-core
 - [x] Port rest of http
 - [ ] Port to the new IO abstraction
 - [x] get rid of unnecessary materializer parameters
Similarly to the client side, this should read more like this in the end:

```scala
val networkIn: Source[ByteString] = ...
val networkOut: Sink[ByteString] = ...

val userFlow: Flow[HttpRequest, HttpResponse] = // can either be provided from the outside or created from proxies like now

val parsing: Flow[ByteString, (HttpRequest, ResponseRenderingContext)] =
  Flow[ByteString]
      .transform("rootParser", () ⇒ rootParser.copyWith(warnOnIllegalHeader))
      .splitWhen(x ⇒ x.isInstanceOf[MessageStart] || x == MessageEnd)
      .headAndTail
      .collect {
        case (RequestStart(method, uri, protocol, headers, createEntity, _), entityParts) ⇒
          val effectiveUri = HttpRequest.effectiveUri(uri, headers, securedConnection = false, settings.defaultHostHeader)
          val effectiveMethod = if (method == HttpMethods.HEAD && settings.transparentHeadRequests) HttpMethods.GET else method
          HttpRequest(effectiveMethod, effectiveUri, headers, createEntity(entityParts), protocol)
      }

val rendering: Flow[(HttpResponse, ResponseRenderingContext), ByteString] =
  Flow[HttpResponse]
    .transform("renderer", () ⇒ responseRendererFactory.newRenderer)
    .flatten(FlattenStrategy.concat)
    .transform("errorLogger", () ⇒ errorLogger(log, "Outgoing response stream error"))

// #15957
def withContext[T, U, C](flow: Flow[T, U]): Flow[(T, C), (U, C)] = // do graph stuff only in here

val userPipeline: Flow[(HttpRequest, ResponseRenderingContext), (HttpResponse, ResponseRenderingContext)] =
  withContext(userFlow)

val pipeline =
  networkIn
    .connect(parsing)
    .connect(userPipeline)
    .connect(rendering)
    .connect(networkOut)

pipeline.run()

Http.IncomingConnection(tcpConn.remoteAddress, userIn, userOut)
```