Change socket to non-blocking sooner

Put new socket connections into non-blocking mode right after the
connection is accepted instead of waiting until the connection is
handled. Doing things the previous way meant there was the potential
that a socket could get sent to recvall() in blocking mode which could
deadlock the daemon preventing any new connections.
Fix potential deadlock

Must move the register_read_handler() call in handle_connection_read()
to the very end. Previously, the call was done before several parts of
code that would close the socket and return() if an error occurred.

An example of when this deadlock would occur is when a connection has
made it to handle_connection_read(). A call to register_read_handler()
would occur soon after the packet was read using recvall() setting up
the daemon to handle the next packet sent by the client. However, there
could be an issue where the packet version is not correct as an example.
The daemon would then close that socket and return() from
handle_connection_read().

If you are lucky this closed connection would then go through
handle_events(), see that the socket was closed, forward it on to it's
handler (handle_connection_read()) where the call to recvall() would
return an error because the socket was closed and just log about the
connection being closed and return() from the handle_connection_read().

There is the chance though that between the time when the socket was
closed in handle_read_connection() and it getting processed by
handle_events() a new connection comes in and assumes the same fd as the
closed connection.

Previous to commit c980ccff the socket would not get put into
non-blocking mode right away. That means the socket gets processed by
handle_events() where rhands (read handlers) are processed first. It
would see that this socket was changed and forward things on to
handle_connection_read() where things will deadlock at recvall().
Remove unnecssary call to encrypt_cleanup()
Updated Changelog
Prep for 2.9.3 release