This class reimplements the much of the reconnect logic of the existing
SocketAppenderBase but does so by exposing an API that is easy to
integrate in a class that needs to handle automatic outbound connection
re-establishment, and in a way that is more easily tested.  This should
be adopted into SocketAppenderBase after some operational experience is
gained with it.

Dealing with IOException on Socket.close in each finally where it
appears is a pain...

SSLServerSocketAppender has an 'ssl' property of type SSLConfiguration.

LOGBACK-822: add ServerSocketAppenderBase and SSLServerSocketAppenderBase to core

These classes are all part of the implementation and should not be
visible outside of the package.

The ObjectInputStream reference (oos) was being closed without checking
to see if it was ever created.  If the ObjectInputStream constructor
happened to throw an exception, we'd have an NPE here.  Not likely, but
worth handling properly.

This was done to be consistent with the implementation in
ServerSocketAppenderBase, but isn't strictly required, as all concurrent
tasks for this server will be blocked in I/O calls, not thread waits.

This ensures that any clients that are blocked waiting to take the next
event from the queue will shut down cleanly.

This will allow the created ExecutorService to be shutdown in the
relevant stop method.

In the existing RemoteAppenderStreamClient, an InputStream obtained from
the underlying socket was passed in the constructor.  While the client
implementation closed the stream, it did not close the socket.  Now the
socket is passed to the client to ensure the socket gets closed.

Implemented lifecyle and appender methods, and added unit tests and
supporting classes.

Previously only the queue size was exposed.  Having the queue itself
exposed for configuration makes it easier to write a unit test that
isn't overly complicated.

The stop method was iterating a copy of the collection.  Since this is
exactly what accept(ClientVisitor) does, stop can simply delegate to
accept with a visitor that closes each visited client.

This method will allow a user of a ServerRunner to visit each of the
connected clients in order to do something with the client.

When the ConcurrentServerRunner is moved to core, it cannot reference
directly the Logger and LoggerContext objects.  Now the base class
delegates its logging to a subclass.

The javadoc references to SocketRunner will cause an unwanted important
when this interface is moved to core.

The ServerListener was converted to use a type parameter for the Client
subtype.  The Client interface was stripped down and the
remote-appender-specific methods were moved to a subinterface.  These
changes allowed the ConcurrentServerRunner and ServerSocketListener to
use a generic Client and to be reworked to move all of the
remote-appender-specific code to subclasses.  With these changes the
abstract base classes and interfaces can be moved to core to support
other server types.

LOGBACK-819: added support for a logging server that is configurable in logback.xml