feat(metrics): add Changeless::restrict for tuple-combinator ergonomics

Adds a thin constructor for the "restrict any metric to changeless solutions"
pattern. The previous workaround was the verbose tuple combinator
`((metric, 1.0), (Changeless { target, change_policy }, 0.0))`, which is
how the new method is implemented:

    Changeless { target, change_policy }
        .restrict(LowestFee { target, long_term_feerate, change_policy });

For metrics like `LowestFee` whose bounds happen not to differ per-regime on
changeless selections, this is equivalent in BnB round counts to a dedicated
`Changeless<Lowest>Fee` metric — see the
`benches/changeless_dedicated_vs_tuple` data. For `Waste`-shape metrics with
genuinely cross-regime bounds, the dedicated `ChangelessWaste` is much
tighter; the rustdoc on `restrict` documents this trade-off.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: evanlinjin

src/metrics/changeless.rs

@@ -10,6 +10,36 @@ pub struct Changeless {
     pub change_policy: ChangePolicy,
 }
 
+impl Changeless {
+    /// Restrict another metric to changeless solutions only.
+    ///
+    /// Returns the tuple combinator `((metric, 1.0), (self, 0.0))` — `metric` does the actual
+    /// scoring; `self` (with weight `0.0`) contributes nothing to the score but its `score`
+    /// returning `None` whenever the selection has change is what filters out non-changeless
+    /// solutions. The `bound` likewise propagates through both factors: as soon as
+    /// `Changeless::bound` returns `None` (no changeless descendant possible per
+    /// `change_lower_bound`), the whole branch is pruned.
+    ///
+    /// ```
+    /// use bdk_coin_select::metrics::{Changeless, LowestFee};
+    /// # use bdk_coin_select::{Target, ChangePolicy, FeeRate, DrainWeights, TargetOutputs};
+    /// # let target = Target { fee: Default::default(), outputs: TargetOutputs::fund_outputs([]) };
+    /// # let change_policy = ChangePolicy::min_value(DrainWeights::NONE, 0);
+    /// # let long_term_feerate = FeeRate::ZERO;
+    /// let metric = Changeless { target, change_policy }
+    ///     .restrict(LowestFee { target, long_term_feerate, change_policy });
+    /// ```
+    ///
+    /// Note that for `LowestFee` specifically this is equivalent in `BnB` round counts to a
+    /// dedicated changeless-LowestFee metric (the cross-regime branch in `LowestFee::bound`
+    /// does not fire on changeless selections). For metrics with bounds that *do* differ
+    /// per-regime — like the `Waste` metric — a dedicated `ChangelessWaste` is significantly
+    /// tighter.
+    pub fn restrict<M: BnbMetric>(self, metric: M) -> ((M, f32), (Self, f32)) {
+        ((metric, 1.0), (self, 0.0))
+    }
+}
+
 impl BnbMetric for Changeless {
     fn score(&mut self, cs: &CoinSelector<'_>) -> Option<Ordf32> {
         if cs.is_target_met(self.target)