perf(node): throttle RPC polling during sync so block download isn't slowed

The full-node wallet polled the daemon at the per-tab cadence regardless of sync state.
On the Peers/Network tab that meant getpeerinfo every 5s + core every 5s + a full
transaction scan on every new block — and blocks arrive fast during sync. Each of those
calls takes the daemon's cs_main lock, the same lock block connection needs, so the node
synced noticeably slower than on the lightweight Console tab (core 10s, no peer polling).

Make the refresh cadence sync-aware:
- RefreshScheduler::kSyncProfile {core 10s, transactions/addresses/peers disabled} is applied
  to ALL tabs while state_.sync.syncing, and reverts to the per-tab profile when sync ends.
  applyRefreshPolicy() picks the profile; update() re-applies it on the syncing<->synced
  transition. This suppresses getpeerinfo and the per-block tx scan during sync (that data is
  incomplete mid-sync anyway) — every tab now syncs as fast as Console.
- collectCoreRefreshResult(rpc, includeBalance): skip z_gettotalbalance (wallet lock + cs_main)
  while syncing; only getblockchaininfo runs, which is also what drives sync-progress detection.
  applyCoreRefreshResult already leaves the balance untouched when balanceOk is false.

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

src/app_network.cpp

@@ -664,7 +664,14 @@ App::RefreshIntervals App::getIntervalsForPage(ui::NavPage page)
 
 void App::applyRefreshPolicy(ui::NavPage page)
 {
-    network_refresh_.setIntervals(getIntervalsForPage(page));
+    // While the daemon is syncing, override the per-tab cadence with the low-impact sync profile so
+    // the wallet stops contending for the daemon's cs_main lock (frequent getpeerinfo / per-block
+    // transaction scans / balance polls slow block connection). This makes every tab sync as fast
+    // as the Console tab does today. Reverts to the per-tab profile once sync finishes.
+    refresh_policy_syncing_ = state_.sync.syncing;
+    network_refresh_.setIntervals(refresh_policy_syncing_
+        ? services::RefreshScheduler::kSyncProfile
+        : getIntervalsForPage(page));
 }
 
 bool App::currentPageNeedsWalletDataRefresh() const
@@ -1159,10 +1166,13 @@ void App::refreshCoreData()
                 ? fast_rpc_.get() : rpc_.get();
     if (!w || !rpc) return;
     ui::NavPage tracePage = current_page_;
+    // Skip the balance call while syncing (it's incomplete anyway and takes the wallet lock +
+    // cs_main). Captured on the main thread to avoid reading state_ off the worker thread.
+    const bool includeBalance = !state_.sync.syncing;
 
-    auto enqueued = network_refresh_.enqueue(services::NetworkRefreshService::Job::Core, *w, [this, rpc, tracePage]() -> rpc::RPCWorker::MainCb {
+    auto enqueued = network_refresh_.enqueue(services::NetworkRefreshService::Job::Core, *w, [this, rpc, tracePage, includeBalance]() -> rpc::RPCWorker::MainCb {
         AppRefreshRpcGateway refreshRpc(*rpc, traceSource(tracePage, "Core refresh"));
-        auto result = NetworkRefreshService::collectCoreRefreshResult(refreshRpc);
+        auto result = NetworkRefreshService::collectCoreRefreshResult(refreshRpc, includeBalance);
         return [this, result]() {
             try {
                 NetworkRefreshService::applyCoreRefreshResult(state_, result, std::time(nullptr));