perf: make LowestFee's BnB bound max_weight-aware

The bound was deliberately cap-blind (admissible but loose): it credited
improvements the weight budget can't actually afford. Tighten it in the
cap-binding regime by refusing those improvements:

- Not-funded ("slurp") branch: reaching the feerate needs a perfect input
  weighing `scale * to_resize.weight`. `to_resize` is the best value-per-weight
  input available, so if even that (fractionally) can't fit the remaining
  weight budget, no within-cap selection down this branch reaches the target
  -> prune. This is the fractional relaxation, so it never prunes a branch
  that has an integer within-cap solution.
- Changeless "recover value by adding change" branch: only credit the
  improvement if a change output fits the cap. Clearing the dust threshold
  needs more (heavier) inputs and the change output adds weight, so if change
  doesn't fit now it never will down this branch -> keep `current_score`.

Both terms stay admissible (validated by `ensure_bound_is_not_too_tight`) and
BnB still finds the optimum (`can_eventually_find_best_solution`). Only takes
effect when `max_weight` is set.

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

Author: evanlinjin

src/metrics/lowest_fee.rs

@@ -161,7 +161,17 @@ impl BnbMetric for LowestFee {
 
                 let best_score_with_change =
                     Ordf32(current_score.0 - cost_of_no_change as f32 + cost_of_adding_change);
-                if best_score_with_change < current_score {
+                // max_weight-aware: recovering that value requires a change output (and more
+                // inputs to clear the dust threshold), which only makes the tx heavier. If a change
+                // output can't fit the cap now it never will down this branch, so don't credit the
+                // improvement — keep `current_score` (a tighter, still-admissible bound).
+                let change_output = Drain {
+                    weights: self.drain_weights,
+                    value: 0,
+                };
+                if cs.is_within_max_weight(target, change_output)
+                    && best_score_with_change < current_score
+                {
                     return Some(best_score_with_change);
                 }
             }
@@ -243,6 +253,19 @@ impl BnbMetric for LowestFee {
                 }
             }
 
+            // max_weight-aware: reaching the feerate needs a perfect input weighing
+            // `scale * to_resize.weight`. `to_resize` is the best value-per-weight input available,
+            // so if even that (fractionally) can't fit the remaining weight budget, no within-cap
+            // selection down this branch reaches the target -> prune. This is the fractional
+            // relaxation, so it never prunes a branch that has an (integer) within-cap solution.
+            if let Some(max_weight) = target.max_weight {
+                let budget =
+                    max_weight.saturating_sub(cs.weight(target.outputs, DrainWeights::NONE));
+                if scale.0 * to_resize.weight as f32 > budget as f32 {
+                    return None;
+                }
+            }
+
             // `scale` could be 0 even if `is_funded` is `false` due to the latter being based on
             // rounded-up vbytes.
             let ideal_fee = scale.0 * to_resize.value as f32 + cs.selected_value() as f32