feat(parameters): support common Rust types as parameters

[azerupi]

Problem

A parameter could only be declared with the Rust type that most directly represents one of the nine ROS 2 parameter types. A list of names had to be Arc<[Arc<str>]> and a port number an i64, even where the application would naturally use Vec<String> and u16.

let wheels: MandatoryParameter<Arc<[Arc<str>]>> = node
    .declare_parameter("wheels")
    .default_string_array(["left_wheel", "right_wheel"])
    .mandatory()?;

let port: MandatoryParameter<i64> = node
    .declare_parameter("port")
    .default(8080)
    .mandatory()?;
// nothing stops this being set to 70000, and nothing says so in the descriptor

Solution

Implement ParameterVariant for the Rust types an application would reach for anyway, so the declaration says what the value is and the narrowing that implies is enforced and reported.

let wheels: MandatoryParameter<Vec<String>> = node
    .declare_parameter("wheels")
    .default(vec!["left_wheel".to_string(), "right_wheel".to_string()])
    .mandatory()?;

let port: MandatoryParameter<u16> = node
    .declare_parameter("port")
    .default(8080)
    .range(1024..)
    .mandatory()?;

Types added

Strings and paths	String, PathBuf
Narrow integers	i8, i16, i32, u8, u16, u32
Narrow float	f32
Arrays	Vec<T> for every scalar above, plus Vec<i64>, Vec<f64>, Vec<bool>, Vec<u8>

Vec<u8> is the one exception to array mapping: a sequence of bytes is a ROS 2 byte array, not an integer array. u64, usize, i128 and u128 are deliberately unsupported because a parameter value is stored as an i64

Narrowing is enforced

A conversion back from a stored value can be partial, not every i64 is a u16. The type check added in the previous PR rejects those on both write paths, so a narrow parameter can never hold a value that goes out of bounds of the Rust type, including over SetParameters:

$ ros2 param set /node port 70000
Setting parameter failed: Parameter value is not valid for this parameter's type:
70000 is out of range for u16, which accepts 0..=65535

Arrays are checked element-wise and the rejection says which element was at fault:

element 2: 70000 is out of range for u16, which accepts 0..=65535

Reading an element goes through the scalar type's own conversion, so what a u16 may be is decided in exactly one place.

Narrowing

A u16 is bounded by what it can hold, so the limits ride on the type's ParameterConversion and combine with ranges:

.range(1024..)     // declared: lower 1024, upper open
                   // reported: 1024..=65535

$ ros2 param describe /node port
  Constraints: 0..=65535
  Integer range: 1024..65535

rqt_reconfigure and anything else reading the descriptor now sees the real bound, instead of an operator discovering it by having a value rejected. Constraints replace (the declaration's text wins), ranges narrow (a value must satisfy both).