make DefaultLoader.export_types = false un-export already exported types
document the root_loader option of RemoteProcesses::Client#initialize
remove the creation of an aggregate loader in RubyTasks::ProcessManager

The goal of this loader was to allow manual registration of models,
but that is not needed as we can manually register on the root loader
itself.
fix spawning processes with the wait option set to true

This is meant to allow waiting forever, but was instead interpreted
as "do not wait".
remove access to the global name service object in the process spawning code paths
improve suggestions in case a process dies
test: fix simplecov integration

Both simplecov and minitest' autorun use at_exit to perform their
duties. Unfortunately, the order of at_exit calls is inverse to
the loading order, which makes it fragile (simplecov integration
got broken because requiring minitest/autorun got moved at the top
of the test file).

Instead, use simplecov's SimpleCov.at_exit to disable exit handling,
and run coverage computation using Minitest.after_run
remote_processes: write a test suite
remote_processes: do not explicitly call exit() when the server quits

This makes it impossible to use it in tests, and is really bad
practice.
remote_processes: use constants instead of harcoded control codes
remote_processes: support given a port of 0 to Server#initialize

This is really useful in tests to make sure we won't collide with
already existing servers, as well as ensure that both client and
server are using their port parameter properly
remote_processes: rename Server#options to Server#default_start_options

'options' was really confusing, as it is not the server options,
but the options that should be passed to #spawn by default
remote_processes: remove hardcoded access to the default pkgconfig loader

Accessing the singleton object in the class code is obviously
bad practice, and made it impossible to use another loader,
for instance in tests.
remote_processes: initialize Process with the deployment model, not its name

Client already loads the required deployment model, so it is really
useless to have Process re-resolve it like this.
remote_processes: fix loader handling in Client

While it is important to verify that the remote process has a
deployment / task model when required, the code must use the
root loader to load things (and NOT the specific loader). Otherwise,
we might end up with multiple versions of the same model because
they got loaded from different sources.
remote_processes: refactor the Server code

This is mostly aimed at improving both testability and readability
remote_processes: implement joining a remote process
remote_processes: implement a command to quit the server remotely
fix initialization of default loaders

Now that oroGen auto-adds the child loaders to aggregates, we
don't need to do it ourselves. However, given how we try to do
some lazy initialization of all the default loaders, getting it
"just right" is tricky.

One needs to first make sure that the root default loader is
initialized by calling Orocos.default_loader and *then* instanciate
the new one. Otherwise, we would get two instances of each:

   default_file_loader
     @default_file_loader is nil in first call
     calls default_loader AND creates the new loader
     default_loader:
       @default_loader is nil in first call
       calls default_file_loader
       @default_file_loader is still nil
       creates a new loader (second one !)