feat(parameters): derive descriptor constraints from the parameter type

[azerupi]

The code changes in this PR have been assisted by Claude Code but I have reviewed and iterated on the code.

Problem

additional_constraints in a parameter descriptor was only ever whatever the declaration passed to .constraints(). For a type with a closed set of valid values, a string-backed enum being the obvious case, that means every declaration site has to restate the type's rules as free text:

node.declare_parameter("mode")
    .default(Switch::On)
    .constraints("one of: on, off")     // restated here
    .mandatory()?;

node.declare_parameter("fallback_mode")
    .default(Switch::Off)
    .constraints("one of: on, off")     // and here
    .mandatory()?;

Nothing keeps that text in sync between the different declarations and with the type. As the type gains variants it is very easy to forget to update each declaration and that is when the user adds .constraints() to begin with. So often there would be no constraints or the constraints would be outdated and a user running ros2 param describe would not be helped.

Solution

Add a way for a type to describes its own constraints once:

impl ParameterVariant for Switch {
    fn kind() -> ParameterKind { ParameterKind::String }

    fn type_constraints() -> Option<Arc<str>> {
        Some("one of: on, off".into())
    }
}

and every declaration that sets no constraints of its own inherits it:

node.declare_parameter("mode").default(Switch::On).mandatory()?;

$ ros2 param describe /node mode
  Constraints: one of: on, off

An explicit .constraints() still wins, for a rule that belongs to one declaration rather than to the type:

.constraints("must be off on tuesdays")     // this, not the type's text

The constraint rides on the declaration's ParameterConversion (added in a prior PR), which is already where a parameter's representation is described. of_variant() fills it from T::type_constraints(), so a type with a ParameterVariant impl gets the behaviour above for free.

That placement also means a hand-written conversion can describe its values with no type to hang the rules on:

let positive_seconds = ParameterConversion::double(
        Duration::as_secs_f64,
        |v| if v > 0.0 { Duration::try_from_secs_f64(v).map_err(|e| e.to_string()) }
            else { Err("must be greater than zero".into()) },
    )
    .with_constraints("must be greater than zero");

To make this work the API grows to have

• ParameterVariant::type_constraints() -> Option<Arc<str>> with a default implementation that defaults to None. This is purely additive and not a breaking change. Existing code continues to compile.
• ParameterConversion::with_constraints() and ::constraints().