`Next` will be called via its `process()` method when invoked by
http-interop middleware; as such, it can invoke a separate method on
Dispatch.

This patch introduces `Dispatch::process()`, which then determines how
to delegate the route provided. For non-http-interop middleware, it will
raise an exception if the `Dispatch` instance does not have a response
prototype injected, or if the request is a non-server-side request. When
dispatching http-interop middleware, if an exception is caught, it
raises exceptions for the same conditions, but otherwise delegates to
the next error handler.

Extracted actual handler processing into:

- dispatchCallableMiddleware()
- dispatchInteropMiddleware()

Each now tests for the handler type received and proxies to the
appropriate method.

…esent

`Next` now implements `DelegateInterface`, to allow usage with
PSR-15/http-interop middleware.

For this to work, the following changes were made:

- `Next` now optionally allows setting a response prototype. If none is
  set when `__invoke()` is first called, the instance will memoize the
  response.
- `setResponsePrototype()` also sets the response prototype on the
  composed `Dispatch` instance.
- `process()` was added, and programmed to operate exactly as
  `__invoke()`, with the following additional behaviors/behavior
  changes:
  - it calls `Dispatch::process()` instead of `Dispatch::__invoke()`.
  - if the queue is empty:
    - if no response prototype exists, an exception is thrown
    - if the request is not a server request, an exception is thrown
    - if one exists, that value will be passed to the `$done` handler
  - if delegating to the next in the queue, it uses its own `process()`
    method, and not the `__invoke()` method.
  - if the middleware dispatched does not return a response, and no
    response prototype is present, it raises an exception.
- internal methods typehinting on `ServerRequestInterface` were updated
  to hint on `RequestInterface` instead, as they were only operating on
  methods defined in that looser interface.

`Next`:

- Allows composing a `DelegateInterface` instance as the `$done`
  property. Invokes this differently based on whether it is callable or
  a delegate, and now only raises exceptions for missing response
  prototype or invalid request type when invoking a callable.

`MiddlewarePipe`:

- Now implements http-interop `ServerMiddlewareInterface`
- Added response prototype composition; can set it, as well as test if
  one is already set.
- Updated `pipe()` to allow piping http-interop middleware.
- `__invoke()` now injects its `$response` argument as the `Next`
  response prototype.
- Added `process()`:
  - Creates a `Next` instance using the `$delegate` provided.
  - Sets the `Next` response prototype if it has one composed itself.
  - Calls `Next::process()` with the provided request.
  - Returns the result if it is a response, but otherwise the composed
    response prototype.

`Dispatch`:

- Prior to dispatching `MiddlewarePipe` middleare, it now injects a
  `MiddlewarePipe` with its own response prototype if the pipeline does
  not yet compose one.

- `$done` verbiage is retained *within* the `__invoke()` and `process()`
  methods, but the property name and `dispatchDone()` methods are
  renamed.

…when piping when possible

Backports the `CallableMiddlewareWrapper` from the dev-2.0.0 branch;
`MiddlewarePipe::pipe()` will now decorate callable middleware *if a
response prototype is present*; if not, it continues as normal.

If a Next instance is passed to CallableMiddlewareWrapper, do not close
over it, as it is already invokable with the expected arguments.

Error middleware will be removed in 2.0.0, and will be handled specially
anyways.

…ferently

`pipe()` now detects if callable middleware has two arguments, with the
second type-hinting on `DelegateInterface`; if so, it wraps it in a new
class, `CallableInteropMiddlewareWrapper`, which simply proxies to the
callable middleware.

Will not be used internally, but can be used by existing middleware in
order to adapt it for http-interop.

…g a Delegate

Added extensive section on http-interop.

Since `MiddlewarePipe` now allows piping http-interop middleware, and
version 2.0.0 will remove the `MiddlewareInterface`, these can be
written as http-interop middleware instead.

…dler

Each now implements `__invoke()`, and has it proxy to `process()` after
first wrapping the `$next` argument in a `CallableDelegateDecorator`.

Primarily, to demonstrate http-interop middleware wherever possible.

Thanks, @michaelmoussa!

Suggested by @michaelmoussa

Per @xtreamwayz

- Per @xtreamwayz

…aled by test

Updated `process()` to assign local `$middleware` variable to
`$middleware` property value.

- per @xtreamwayz

- per @xtreamwayz

Ensured all behaviors work as expected.

These needed to be passed to ReflectionMethod, with each element of the
array as discrete arguments; previously, they were passed to
ReflectionFunction, which failed as it cannot handle arbitrary
callables.

Will likely set the response prototype during instantation in
Expressive, and then use that as the default response if none is
provided to `run()`; as such, it cannot be private visibility.