perf: make LowestFee's BnB bound max_weight-aware

The bound was cap-blind: admissible but loose, crediting improvements the
weight budget can't actually afford. Tighten it in the cap-binding regime:

- 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 can't fit the remaining budget, nothing down
  this branch reaches the target within the cap -> prune. It's a fractional
  relaxation, so it never prunes a branch with an integer solution.
- Changeless "recover value by adding change" branch: only credit the
  improvement if a change output fits the cap. Clearing dust needs heavier
  inputs and the change output adds weight, so if change doesn't fit now it
  never will -> keep `current_score`.

Both stay admissible (`ensure_bound_is_not_too_tight`) and BnB still finds the
optimum (`can_eventually_find_best_solution`). No effect unless `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