Named {member}_Count as this is the normal .NET lingo.
removed getsize_array_field c function as well as it is constant,
no need for interop

Idl arrays now map as System.Array instead of List<T>.
This is the more natural C# type for them.

- size gets checked on writing to the native handle of the message.
- change foreach to for to avoid multi threaded race conditions while writing to native memory.
  (the upper bound is now local and cannot be changed from somewhere else)

`List<T>.Count` is of c# type `int`, wich is 32 bit signed.
C does use `sizeof_t` wich is 32/64 bit dependent.
So this does marshal at least correctly, ignoring cast from 64 bit to
32 bit and vice versa for now.
getting marshaling/conversations 100% correct is anoher issue for another day.

Most importent the `IntPtr Handle` property from `ROS2.Interfaces.IDisposable`
should not be public.
`ROS2.Interfaces.IDisposable` was missleading as well.
(`System.IDisposable` is the well kown one)
Made appropriate memers internal as well and added some sealed and static modifiers.
This was done in preperation for adding SafeHandles to avoid memory leaks,
as this would change the implementation detail that was made public by the interfaces.

Abstractions such as interfaces have to be designed for extensability.
See https://docs.microsoft.com/en-us/dotnet/standard/design-guidelines/abstractions-abstract-types-and-interfaces

As of before this commit native recources for rcl_node_t, rcl_client_t,
rcl_publisher_t, rcl_service_t and rcl_subscription_t didn't
get released.

Used a trick from dotnet/runtime to handle the requirement
that node has to be released last.

Also added some TODOs to check return values and for checks near
allocations use the new throw helper.

- Refactored and renamed some methods to be more consistent.
- Added some error handling.
- Don't try to take things if the wait set did return a timeout.

- renamed IMessage to IRosMessage
- moved interfaces for generated types to ROS2 namespace
- renamed interface members
- used `global::*` in some places to avoid name colisions
- added editor browsable never to the members of the interfaces that
schould not be used outside of rcldotnet

- Avoids doing reflection over and over.
- If we can require static abstract interface members this could go away.

- move RCLExeptionHelper from rcldotnet_common to rcldotnet for acces to rcl_get_error_string()
- get error string using rcl_get_error_string() and add this to the exception message
- change throw helper to avoid unrachable code
- also some other cleanup

error CS0136: A local or parameter named 'request' cannot be declared in this scope because that name is used in an enclosing local scope to define a local or parameter

This allows them to be used in switch cases and other places.

This removes a warning when compiling on x64 plattforms.
The C# DllImportAttribute ignores this calling canvention as well, but dosn't give a warning.

Removes stderr output on build.

This was done with an temporary *.csproj file in the root of the repository:

```xml
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
  </PropertyGroup>
</Project>
```

Then run command `dotnet format` (from .NET6) in the root of the repository.

Did some manual whitespace changes as well, mainly indented wrapped parameters.

This avoids doing unnecessary allocations of native ROS messages only to check
that there is no new data. This might be a good thing to do right now as with
guard_conditions there could be probably more times the waitset is ready to fire
some callbacks, so work should be minimized here especially.

…per types"

With "action wrapper types" this means the ROS messages and services that add the `GoalId`, `TimeStamp` or other fields on top of the user defined types for the action.
The introduced methods in `IRosActionDefinition` are needed to work around the missing existential type support in C# (dotnet/csharplang#5556).

…apper types"

This uses the base type `IMessage` to get around the cyclic references.

…ase class

The field access after Interlocked.CompareExchange might not reflect the updated value.
Or does it? Anyways this makes it more clear.

…edbackMessage

This does not change the C# side of the generated messages to avoid even more complexity in the templates.
As bools in C# pInvokes get marshalled as 32 bit integer by default there is no strictly need to change the code for bool fields.

Most of the documentation was taken from ros2_rust. https://github.com/ros2-rust/ros2_rust/blob/main/rclrs/src/qos.rs