Handling Different Channels & Delegating Handshake
Digging into Ratchet code I discovered that connection flow looks like that:

1. Open connection
2. Negotiate using HTTP Upgrade procedure
3. Delegate connection open event to `ConnectionInterface` instance

### Handshake Validation
I found an annoying problem with second step of the process, which goes as follow:
1. Handshake negotiator is called (`ServerNegotiator` - hardcoded in `WsServer` constructor)
2. Upgrade request is verified by `ServerNegotiator::handshake` using `RequestVerifier`:
 - Method is verified to be `GET` (RFC)
 - HTTP Version is verified to be `1.1` (RFC)
 - Request URI is verified to ~~~be `/`~~~ start with `/`
 - Host is verified to be not empty *(doh!)*
 - Upgrade header is validated (RFC)
 - `Connection` header is validated (RFC)
 - `Sec-WebSocket-Key` is validated (RFC/b64 - spec doesn't call for this)
 - `Sec-WebSocket-Version` is verified to support v13 (RFC)
3. Handshake response is produced by `ServerNegotiator`

### Problem?
I see few problems originating from hardcoded assumptions. In the low level:
1. `ServerNegotiator` instance is hardcoded to use provided `RequestVerifier`
2. `RequestVerifier` contains myriad of assumptions which should be delegated to an application logic
3. `WsServer` forces `X-Powered-By` header to contain `Ratchet/x.y.z`

These low-level assumptions pose problem while designing high-level logic:
1. There is no way to route different topics based on negotiation request URI/`Host` header/client IP etc
2. There is no sane way to modify negotiation response (e.g. add custom headers or remove `X-Powered-By` which is required for some certifications)
 

### Possible solution
`ServerNegotiator` should behave according to its name and **only** ensure request is valid according to RFC-6455. Rest of the validation logic (e.g. `Host`) should be outsourced to the application logic. This is relatively simple to achieve - WsServer should accept custom `RequestVerifier` instances (maybe as some interface?).

The second part of the problem is dealing with handshake response. Currently `X-Powered-By` header is set to "Ratchet" in `ServerNegotiator` as well as in `WsServer` to the name with version. I think the whole `ServerNegotiator` instance should not be hardcoded in `WsServer` but rather settable. Built-in `ServerNegotiator` should set the `X-Powered-By` with version and `WsServer` should not attempt to modify the response. We can either solve this by providing custom negotiator extending `ServerNegotiator` or provide interface similar to message/connection handlers in which external class is called to modify `Response` object.

WDYT?