Provide programmatic ways to create karyon servers

Currently, the only way to create karyon based servers is to provide a main class that contains annotations to specify the guice modules.

This change provides a single entry point `Karyon` to creating karyon based servers. It is a factory class that gives ways to create all flavors of interactions with karyon.

The current `KaryonServer` class has been renamed to `KaryonRunner`

This change also separates servo integration into a different module `karyon-servo`
For Guice applications usually we will need to configure ```RxServer```/```ConnectionHandler``` via injected dependencies. It is not possible with the current factories. 

If we bind ```RxServer``` in Guice container, than we could use ```postConstruct``` hook to complete the configuration (for example inject metrics listener). We could provide some helper classes to make the mechanics of it more user friendly. Dealing with ```ConnectionHandler``` is more difficult, as it is totally out of control. And it is the most important as the ```ConnectionHandler``` must somehow hook into the rest of the application that lives in the container.

A general approach that would work better is:
* create a container with all the components, except RxServer(s)
* build RxServer using artifacts created directly (pipeline configurator)

Static factory like in this class would be helpful if an application does not use Guice, but in this case it should probably be based on karyon-core.