Since the clientserver code does not understand what a `Player` is, we can't have `Handshake.getPlayer()`. Since this
method is only used called on `ServerHandshake`, the method has been moved there and removed from `Handshake` and
`ClientHandshake`.

Additionally, the `Handshake` interface does not need to inherit from `MessageHandler`. Implementations can be
`MessageHandler` if they need to be (and they current do), but nothing about the handshake process inherently requires
this to be true.

Both `WebRTCConnection` and `WebRTCServer` have had the following changes made:
1. Instead of accepting a `ServerConfig`, they both accept a `String` server name. This was the only part of the config
   used in the WebRTC code.
2. Instead of calling `MapTool.stopServer()` and `MapTool.showError()`, they now both have `Listener` interfaces that
   communicate the events that needed these actions take. The `ConnectionFactory` is responsible for hooking these up to
   the `MapTool` methods. I'm not a big fan of this approach, but I wanted to avoid complete reworks of server
   initialization and connection management, so this is what I went with.

Also a bunch of `if` statements were gifted braces.

This avoids putting `PeerConnectionObserver` and `RTCDataChannelObserver` in the API of `WebRTCConnection`. Not doing
this will require subtle dependency requirements once in a separate project.

Left behind was `ConnectionFactory` as it is really a MapTool-specific tool for building connections and servers rather
than a part of the general client-server logic itself. Also pulled in was `Handshake` and `HandshakeObserver` since they
are used in the client-server and are an important part of the process (the implementations were left behind though).

Common build configurations wered moved into a `shared.gradle` file applied to the root project and
subprojects. Dependencies specific to the clientserver subproject were moved out of the root project to keep things
clear.