Add basic support for system messages

This changes performs the first step of #750, a simplified version with much improved testing. All system messages are handled by `cowboy_protocol` or `cowboy_middleware`. Middlewares, sub_protocols (and handlers) can not change how system messages are handled.

To have `cowboy_middleware` handle a system message a middleware (or sub_protocol) returns:
```erlang
{system, From, Msg, Module, Req, State}
```
Once the system message(s) have been handled control is passed back to the middleware via a `cowboy_sys` callback. Either to continue processing as before:
```erlang
sys_continue(Req, #state{env=Env}) ->
    {ok, Req, Env}.
```
Or to terminate with reason `Reason`:
```erlang
sys_terminate(Reason, _Req, _State) ->
    exit(Reason).
```

For more information please see the commit message or the additions to the guide.

Help is required to test handling of system messages when a websocket handler receives the message in the  `websocket_payload_loop` receive clause.
`proc_lib` catches any exceptions and calls `exit(Reason)`[1]. This means a process exiting due to an error won't have the stacktrace in it's exit signal/monitor. By exiting explicitly here the excepted/"best" exit reason is generated. That is the process exits with the same reason as if `proc_lib` was not used. This creates the same exit reason that an OTP behaviour would give. Note that all OTP behaviours exit explicitly with `exit/1` with the stacktrace included in a simialr fashion due to their use of `case catch Mod:Fun(Arg) of`.

As we are catching and exiting here I have changed the middlewares to exit with `exit([{class, Class} | ReasonAsBefore])` when a handler raises an exception so we don't catch it here. This will save generating the line numbers for the stacktrace an extra time. I believe this also makes the exit reasons easier to read in logs.

Note that if we kept the old behaviour (and didn't catch here) the `Class` information would be lost when a handler raised an exception. I feel that we can't revert the catch here as important information for middlewares errors would be lost. I can revert the `exit([{class, Class} | _])` change if you like.

[1] https://github.com/erlang/otp/blob/070fbf084c2987959b321c4fd9d9d65202dc7984/lib/stdlib/src/proc_lib.erl#L253-L264