Avoid heap-allocating background processor futures

[Abeeujah]

The persistence loop in process_events_async boxed each task future
(ChannelManager, network graph, scorer, sweeper, LiquidityManager)
before handing it to the Joiner, incurring a heap allocation per task
on every iteration. Box::pin was only needed to satisfy the Joiner's
Unpin bound when our MSRV predated core::pin::pin!.

Now that the MSRV is 1.75, replace Box::pin with core::pin::pin! so the
futures live on the stack. Pin<&mut F> is Unpin, so the Joiner bounds
still hold. To pin every future before the Joiner borrows it, build all
five uniformly at the end of the iteration: run the synchronous timer
checks and side effects first, capture their outcomes in flags, and
gate each future's work behind those flags. Futures whose work is
skipped resolve to Ok(()) immediately, preserving the previous behavior
where an unset Joiner slot was treated as Ready(Ok(())).

The eager single poll of the ChannelManager future and the early
loop-exit (break) semantics on the scorer/sweeper timers are unchanged.

[ldk-reviews-bot]

I've assigned @valentinewallace as a reviewer!
I'll wait for their review and will help manage the review process.
Once they submit their review, I'll check if a second reviewer would be helpful.

[ldk-claude-review-bot]

No functional issues found.

I reviewed the refactor carefully against the original behavior:

• Side-effect ordering preserved: the synchronous timer checks (archive, prune + remove_stale_channels_and_tracking_with_time, scorer time_passed, sweeper) all run in the same order before any future is polled. Since futures are lazy, building them after the sync work (rather than interleaved) does not change behavior.
• Skipped-work semantics preserved: every future is now unconditionally set into the Joiner, but each gates its work behind a flag (needs_cm_persist, network_graph_to_persist, persist_scorer, persist_sweeper, LM presence) and resolves to Ok(()) when skipped — matching the old "unset slot → Ready(Ok(()))" behavior.
• Eager CM poll preserved: cm_fut is still polled once with the dummy waker; Ready is stashed via set_a_res, Pending moves the future into the Joiner via set_a. No double-flush, no double-encode (encode()/flush() remain gated behind needs_cm_persist inside the async block).
• break semantics preserved: scorer/sweeper Some(true) => break still exit before the join, and None no longer persists (equivalent to the old None => {} leaving the slot unset).
• Drop order: pending_monitor_writes is still captured after get_and_clear_needs_persistence() and declared before the futures, so the borrow/drop-order invariant holds.
• Pin<&mut F> is Unpin, so the Joiner bounds are satisfied; type inference for the conditionally-set a slot is still resolved from the set_a(cm_fut) call.

Cross-cutting note (not blocking): the scorer_fut binding (around lib.rs:1294) is split across lines in a way that differs from the sibling let network_graph_fut = core::pin::pin!(...) style; running cargo fmt would likely collapse it, so double-check CI's rustfmt check passes.

[GideonBature]

Just a nit: wouldn't it be better if it is "needs_cm_persist is set. Declared..." or "needs_cm_persist is set, declared..." if we will still go with the comma.