introduce the ideas of Before and After middlewares

[jbr]

For discussion, a functional sketch

context

Due to the lack of AsyncFn types in rust currently, we cannot describe the bounds for an async function that has a lifetime in the arguments. As a result, there's no way to write

// this example is not possible
app.middleware(|req: Request<()>, next: Next<()>| async move {
  next.run(req).await
});

and instead function middlewares look like:

// current signature
fn minimal_middleware<'a>(
    request: Request<()>,
    next: Next<'a, ()>,
) -> Pin<Box<dyn Future<Output = Result> + Send + 'a>> {
    Box::pin(async { next.run(request).await })
}

//--snip--

app.middleware(minimal_middleware);

proposed solution

Because the issue is that Next is not owned, it is possible to write simple async signatures for middlewares that exist on either side of the Next call. This PR called them Before and After middlewares currently, but those names probably can be improved. This PR is predicated on an assumption that a meaningful percentage of app-written middlewares exist as transformations of the request OR the response. This enables the following code.

// possible with this pr
app.middleware(Before(|request: Request<()>| async move { request })));
app.middleware(After(|result: Result| async move { result })));

[yoshuawuyts]

Overall this LGTM. We should add docs though so folks get a sense of what this is about.

Perhaps we should point out that once async closures / async traits land we no longer need this as people should be able to just write middleware inline using closures.