fix: wire up DashPay payment history to wallet transactions

The Payment History screen was always empty because it only read from
the dashpay_payments database table, which was only populated when
payments were sent through the app's DashPay UI. The
process_incoming_payment() function existed but was never called.

Changes:
- Add scan_wallet_transactions_for_dashpay_payments() that cross-
  references SPV wallet transactions against DashPay address mappings
  and saves matches to the dashpay_payments table (idempotent)
- Call it from LoadPaymentHistory backend task for immediate retroactive
  detection when the user opens the Payment History screen
- Call it during SPV reconcile for ongoing automatic detection
- Fix ContactDetailsScreen to load per-contact payment history from DB
  (was initialized empty and never populated)

Closes #688

Author: thepastaclaw

src/backend_task/dashpay.rs

@@ -171,6 +171,40 @@ impl AppContext {
             ),
             DashPayTask::LoadPaymentHistory { identity } => {
                 let identity_id = identity.identity.id();
+
+                // Retroactively scan wallet transactions for DashPay payments
+                // that may not yet be in the dashpay_payments table.
+                // Clone transactions and drop the read lock before scanning
+                // to reduce lock contention.
+                // Iterate all associated wallets — an identity can have multiple.
+                for wallet_arc in identity.associated_wallets.values() {
+                    let wallet_txs = match wallet_arc.read() {
+                        Ok(guard) => guard.transactions.clone(),
+                        Err(_) => continue,
+                    };
+
+                    if wallet_txs.is_empty() {
+                        continue;
+                    }
+
+                    match incoming_payments::scan_wallet_transactions_for_dashpay_payments(
+                        self,
+                        &identity_id,
+                        &wallet_txs,
+                    ) {
+                        Ok(n) if n > 0 => {
+                            tracing::info!(
+                                "Retroactively discovered {} DashPay payment(s) from wallet transactions",
+                                n
+                            );
+                        }
+                        Err(e) => {
+                            tracing::warn!("Wallet transaction scan failed: {}", e);
+                        }
+                        _ => {}
+                    }
+                }
+
                 let records = payments::load_payment_history(self, &identity_id, None)
                     .await
                     .map_err(