refactor(metrics): inline single-use changeless_max_excess

It had one caller (`ub_changeless_input_weight`); fold it in and keep the
union-of-two-regions reasoning as a comment at the call site.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: evanlinjin

src/metrics/changeless_waste.rs

@@ -85,17 +85,6 @@ impl ChangelessWaste {
         self.drain_weights.dust_threshold(self.dust_relay_feerate)
     }
 
-    /// The largest `excess_with_drain_weight` for which a selection is still changeless.
-    ///
-    /// A selection is changeless (see [`drain_value`]) when its excess is `<= drain_spend_cost` OR
-    /// `< dust_threshold`. The union of those two regions is `excess <= max(drain_spend_cost,
-    /// dust_threshold - 1)`, so this is the inclusive upper edge of the changeless region.
-    ///
-    /// [`drain_value`]: Self::drain_value
-    fn changeless_max_excess(&self) -> i64 {
-        (self.drain_spend_cost() as i64).max(self.dust_threshold() as i64 - 1)
-    }
-
     /// Whether every selection reachable down this branch (the current one and any superset of it)
     /// would have a change output — so no changeless solution exists here and the branch can be
     /// pruned.
@@ -131,9 +120,9 @@ impl ChangelessWaste {
     ///
     /// Construct `D_all = cs ∪ all unselected`. If `D_all` itself is changeless, the UB is
     /// `D_all.input_weight`. Otherwise we must exclude enough excess-contributing
-    /// (positive-`effective_value`) candidates to drop `excess_with_drain_weight` down to
-    /// [`changeless_max_excess`]. To MAXIMIZE the remaining `input_weight` we MINIMIZE the excluded
-    /// weight, sorting positive-`ev` candidates by `ev / weight` descending and removing
+    /// (positive-`effective_value`) candidates to drop `excess_with_drain_weight` down to the
+    /// largest still-changeless excess. To MAXIMIZE the remaining `input_weight` we MINIMIZE the
+    /// excluded weight, sorting positive-`ev` candidates by `ev / weight` descending and removing
     /// fractionally until the required `delta` is met.
     ///
     /// The LP relaxation gives a value `>=` any integer solution's excluded weight, so
@@ -142,13 +131,18 @@ impl ChangelessWaste {
     /// subtract from a subset — so the additive subtraction is safe in the UB direction.
     ///
     /// [`bound`]: BnbMetric::bound
-    /// [`changeless_max_excess`]: Self::changeless_max_excess
     fn ub_changeless_input_weight(&self, cs: &CoinSelector<'_>, target: Target) -> f32 {
         let mut d_all = cs.clone();
         d_all.select_all();
         let d_all_iw = d_all.input_weight() as f32;
 
-        let delta = self.excess_with_drain_weight(&d_all, target) - self.changeless_max_excess();
+        // The largest `excess_with_drain_weight` for which a selection is still changeless: it is
+        // changeless (see `drain_value`) when its excess is `<= drain_spend_cost` OR `<
+        // dust_threshold`, and the union of those two regions is `excess <= max(drain_spend_cost,
+        // dust_threshold - 1)`.
+        let changeless_max_excess =
+            (self.drain_spend_cost() as i64).max(self.dust_threshold() as i64 - 1);
+        let delta = self.excess_with_drain_weight(&d_all, target) - changeless_max_excess;
         if delta <= 0 {
             return d_all_iw;
         }