perf(metrics): use lp_min_cost_to_cover in LowestFee bound

Replaces the single-benchmark estimate in `LowestFee::bound`'s "target met,
has change, can we go changeless?" branch with the shared
`lp_min_cost_to_cover` helper. The old code used only the lowest-value_pwu
unselected candidate as a benchmark and assumed it scaled arbitrarily,
which under-estimates the cost when the benchmark's `|ev|` is less than
the amount above the change threshold.

LP-relaxed knapsack handles this correctly: takes the benchmark fully
(it's the most-efficient by definition), then progressively worse-ratio
candidates until the deficit is covered.

The bound is provably tighter than V1 (or equal): for any
`amount <= |ev_benchmark|`, the LP answer equals V1's; for
`amount > |ev_benchmark|`, the LP answer is strictly larger (tighter LB),
because V1 over-scales the benchmark beyond its actual size.

In the synthetic `benches/lowest_fee_bounds` pool the V1/V2 round counts
are identical — the path "amount > benchmark's |ev|" doesn't fire in
this particular pool shape. The tightening is for adversarial / dust-heavy
pools the proptest occasionally exercises.

`ensure_bound_is_not_too_tight` proptest still passes (all 7 LowestFee
tests green).

Removes the TODO comment that pointed at this exact tightening
opportunity.

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

Author: evanlinjin

src/metrics/lowest_fee.rs

@@ -53,43 +53,38 @@ impl BnbMetric for LowestFee {
 
             // I think this whole if statement could be removed if we made this metric decide the change policy
             if let Some(drain_value) = drain_value {
-                // it's possible that adding another input might reduce your long term fee if it
-                // gets rid of an expensive change output. Our strategy is to take the lowest sat
-                // per value candidate we have and use it as a benchmark. We imagine it has the
-                // perfect value (but the same sats per weight unit) to get rid of the change output
-                // by adding negative effective value (i.e. perfectly reducing excess to the point
-                // where change wouldn't be added according to the policy).
-                //
-                // TODO: This metric could be tighter by being more complicated but this seems to be
-                // good enough for now.
-                let amount_above_change_threshold = drain_value - self.change_policy.min_value;
-
-                if let Some((_, low_sats_per_wu_candidate)) = cs.unselected().next_back() {
-                    let ev = low_sats_per_wu_candidate.effective_value(self.target.fee.rate);
-                    // we can only reduce excess if ev is negative
-                    if ev < -0.0 {
-                        let value_per_negative_effective_value =
-                            low_sats_per_wu_candidate.value as f32 / ev.abs();
-                        // this is how much absolute value we have to add to cancel out the excess
-                        let extra_value_needed_to_get_rid_of_change = amount_above_change_threshold
-                            as f32
-                            * value_per_negative_effective_value;
-
-                        // NOTE: the drain_value goes to fees if we get rid of it so it's part of
-                        // the cost of removing the change output
-                        let cost_of_getting_rid_of_change =
-                            extra_value_needed_to_get_rid_of_change + drain_value as f32;
-                        let cost_of_change = self.change_policy.drain_weights.waste(
-                            self.target.fee.rate,
-                            self.long_term_feerate,
-                            self.target.outputs.n_outputs,
-                        );
-                        let best_score_without_change = Ordf32(
-                            current_score.0 + cost_of_getting_rid_of_change - cost_of_change,
-                        );
-                        if best_score_without_change < current_score {
-                            return Some(best_score_without_change);
+                // It might be possible to reduce the long-term fee by adding negative-ev inputs
+                // until `excess` falls below `min_value`, making the selection changeless. The
+                // LP-relaxed minimum cost to do so: sort negative-ev unselected candidates by
+                // `|ev| / value` descending (most excess reduction per unit value cost) and take
+                // fractionally until the deficit is covered. The total value added becomes extra
+                // fee paid (since the changeless tx has no drain to absorb it).
+                let amount_above_change_threshold =
+                    (drain_value - self.change_policy.min_value) as f32;
+                let extra_value_needed_to_get_rid_of_change = super::lp_min_cost_to_cover(
+                    cs.unselected().filter_map(|(_, c)| {
+                        let ev = c.effective_value(self.target.fee.rate);
+                        if ev < 0.0 {
+                            Some((-ev, c.value as f32))
+                        } else {
+                            None
                         }
+                    }),
+                    amount_above_change_threshold,
+                );
+                if let Some(extra_value) = extra_value_needed_to_get_rid_of_change {
+                    // NOTE: the drain_value goes to fees if we get rid of it so it's part of
+                    // the cost of removing the change output.
+                    let cost_of_getting_rid_of_change = extra_value + drain_value as f32;
+                    let cost_of_change = self.change_policy.drain_weights.waste(
+                        self.target.fee.rate,
+                        self.long_term_feerate,
+                        self.target.outputs.n_outputs,
+                    );
+                    let best_score_without_change =
+                        Ordf32(current_score.0 + cost_of_getting_rid_of_change - cost_of_change);
+                    if best_score_without_change < current_score {
+                        return Some(best_score_without_change);
                     }
                 }
             } else {