Executors should allow for more
flexibility and encapsulation.

 create mode 100644 src/ros2cs/ros2cs_core/interfaces/IExecutor.cs

 - Context is a non-static version of Ros2cs without executor functionality
 - Context and Node are now sealed
 - Node is now internal and is preventing its Context from being collected by the GC
 - not calling Dispose may now leak resources since internal collections may be finalized in the finalizer
 - sizes of rcl_node_t and rcl_conext_t are now invisible to C# code

 create mode 100644 src/ros2cs/ros2cs_core/Context.cs
 delete mode 100644 src/ros2cs/ros2cs_core/Ros2cs.cs
 create mode 100644 src/ros2cs/ros2cs_core/interfaces/IContext.cs
 create mode 100644 src/ros2cs/ros2cs_core/utils/MappingValueView.cs

This should prevent misunderstandings regarding being
in an disposed state and being disposed successfully.

 - is now sealed and internal
 - rcl_publisher_t size is now invisible to C# code
 - removes himself from node on dispose
 - prevents Node from being collected by the GC

This interface contains all methods necessary
for executors to process work.
The async version is equivalent to the non-async version
and an optimization opportunity for task based executors.

 create mode 100644 src/ros2cs/ros2cs_core/interfaces/IWaitable.cs

 - is now sealed and internal
 - rcl_subscription_t size is now invisible to C# code
 - removes himself from node on dispose
 - prevents Node from being collected by the GC

 - is now sealed and internal
 - rcl_service_t size is now invisible to C# code
 - removes himself from node on dispose
 - prevents Node from being collected by the GC

 rename src/ros2cs/ros2cs_core/utils/{MappingValueView.cs => MappedValueDictionary.cs} (87%)

 create mode 100644 src/ros2cs/ros2cs_core/utils/LockedDictionary.cs

 - is now sealed and internal
 - rcl_client_t size is now invisible to C# code
 - removes himself from node on dispose
 - prevents Node from being collected by the GC
 - reduced code duplication

These assertions are only enabled in debug mode
and should make finding bugs easier.

This should prevent the GC from starting
finalization while a native call is running.

This enforces more encapsulation than direct internal access.

Make setting `INode.Executor` the task of the executor
since `INode.SwapExecutor` is performing two actions at once
(adding and removing) which can complicate error handling.
Furthermore, `IExecutor.Wake` is split to allow notifying
executors that changes occurred without being forced to wait.

Returning false could fail since the size
of a bool is different between C, C++ and C#.
This is fixed by adding wrappers which assure that
a byte is returned containing 1 for true and 0 for false.
Furthermore this commit adds missing attributes to ref
parameters in NativeRcl or turns them into out parameters.

This allows wrappers to be put in a wait set by delegating to the wrapped implementation.

 - allow for checking which resources became ready
 - implement IExtendedDisposable and IReadOnlyCollection interfaces
 - abstract away wait set resizing and filling
 - hide struct behind IntPtr and C wrappers to handle layout changes and GC moves

It is currently only internal and used for the executor.

 - implementation of IExecutor which has to be spun manually
 - roughly the same as the old spin logic in Ros2cs
 - does not rescan every spin

 create mode 100644 src/ros2cs/ros2cs_core/executors/ManualExecutor.cs
 create mode 100644 src/ros2cs/ros2cs_tests/src/ManualExecutorTest.cs

Guard conditions seem to stay triggered until waited on.

The checks are already done by rcl.

Creating nodes is now thread safe.

The class is now public to allow users to read
the implementation documentation like thread safety.
To prevent access to internal methods the class remains sealed
and uses explicit interface implementations.

The class is now public to allow users to read
the implementation documentation like thread safety.
To prevent access to internal methods the class remains sealed
and uses explicit interface implementations.

The class is now public to allow users to read
the implementation documentation like thread safety.
To prevent access to internal methods the class remains sealed
and uses explicit interface implementations.

The class is now public to allow users to read
the implementation documentation like thread safety.
To prevent access to internal methods the class remains sealed
and uses explicit interface implementations.

The class is now public to allow users to read
the implementation documentation like thread safety.
Furthermore, the primitive collections (and by extension their methods)
are now thread safe.

Async operations are out of scope for this branch.

This commit prevents node primitives from
waiting on the wrong executor while being disposed.

The results are now only exposed as `IEnumerable`s.

This should be more user friendly than `ManualExecutor.Spin`.

Files created by this PR are under the copyright
of ADVITEC Informatik GmbH as suggested by review.
The license is the same as existing files.

This prevents violating the documentation.

This prevents violating the documentation.

To prevent users from having to implement
the feature themselves and provide an alternative
to the old spinning behaviour.
The new executor uses a long running `Task` instead of a `Thread`
to provide better integration with the C# ecosystem.

Threads may fail to wake for some time since the method waits
on a `ManualResetEventSlim` which is reset before the next spin.
To prevent such cases the waiting condition has been modified
to additionally check an integer which is incremented after every spin
to detected if the spin which was waited upon has ended.