refactor: tab-aware prioritized refresh system

Split monolithic refreshData() into independent sub-functions
(refreshCoreData, refreshAddressData, refreshTransactionData,
refreshEncryptionState) each with its own timer and atomic guard.

Per-category timers replace the single 5s refresh_timer_:
- core_timer_: balance + blockchain info (5s default)
- transaction_timer_: tx list + enrichment (10s default)
- address_timer_: z/t address lists (15s default)
- peer_timer_: encryption state (10s default)

Tab-switching via setCurrentPage() adjusts active intervals so
the current tab's data refreshes faster (e.g. 3s core on Overview,
5s transactions on History) while background categories slow down.

Use fast_worker_ for core data on Overview tab to avoid blocking
behind the main refresh batch.

Bump version to 1.1.2.

src/app.h

@@ -221,13 +221,19 @@ public:
     void refreshPeerInfo();
     void refreshMarketData();
     
+    /// @brief Per-category refresh intervals, adjusted by active tab
+    struct RefreshIntervals {
+        float core;         // balance + sync status
+        float transactions; // tx list + enrichment
+        float addresses;    // address lists + balances
+        float peers;        // peer info (0 = disabled)
+    };
+
+    /// @brief Get recommended refresh intervals for a given page
+    static RefreshIntervals getIntervalsForPage(ui::NavPage page);
+
     // UI navigation
-    void setCurrentPage(ui::NavPage page) {
-        if (page != current_page_) {
-            current_page_ = page;
-            if (page == ui::NavPage::Peers) refreshPeerInfo();
-        }
-    }
+    void setCurrentPage(ui::NavPage page);
     ui::NavPage getCurrentPage() const { return current_page_; }
     
     // Dialog triggers (used by settings page to open modal dialogs)
@@ -362,7 +368,6 @@ private:
     // Shutdown state
     std::atomic<bool> shutting_down_{false};
     std::atomic<bool> shutdown_complete_{false};
-    std::atomic<bool> refresh_in_progress_{false};
     bool address_list_dirty_ = false;   // P8: dedup rebuildAddressList
     std::string shutdown_status_;
     std::thread shutdown_thread_;
@@ -438,16 +443,33 @@ private:
     std::string pending_memo_;
     std::string pending_label_;
 
-    // Timers (in seconds since last update)
-    float refresh_timer_ = 0.0f;
+    // Per-category timers (in seconds since last refresh)
+    float core_timer_ = 0.0f;         // balance + sync status
+    float address_timer_ = 0.0f;      // address lists
+    float transaction_timer_ = 0.0f;  // transaction list
+    float peer_timer_ = 0.0f;         // peer info
     float price_timer_ = 0.0f;
     float fast_refresh_timer_ = 0.0f;  // For mining stats
 
-    // Refresh intervals (seconds)
-    static constexpr float REFRESH_INTERVAL = 5.0f;
+    // Default refresh intervals (seconds)
+    static constexpr float CORE_INTERVAL_DEFAULT    = 5.0f;
+    static constexpr float ADDRESS_INTERVAL_DEFAULT = 15.0f;
+    static constexpr float TX_INTERVAL_DEFAULT      = 10.0f;
+    static constexpr float PEER_INTERVAL_DEFAULT    = 10.0f;
     static constexpr float PRICE_INTERVAL = 60.0f;
     static constexpr float FAST_REFRESH_INTERVAL = 1.0f;
 
+    // Active intervals — adjusted by tab priority via applyRefreshPolicy()
+    float active_core_interval_ = CORE_INTERVAL_DEFAULT;
+    float active_tx_interval_   = TX_INTERVAL_DEFAULT;
+    float active_addr_interval_ = ADDRESS_INTERVAL_DEFAULT;
+    float active_peer_interval_ = PEER_INTERVAL_DEFAULT;
+
+    // Per-category refresh guards (prevent worker queue pileup)
+    std::atomic<bool> core_refresh_in_progress_{false};
+    std::atomic<bool> address_refresh_in_progress_{false};
+    std::atomic<bool> tx_refresh_in_progress_{false};
+
     // Mining refresh guard (prevents worker queue pileup)
     std::atomic<bool> mining_refresh_in_progress_{false};
     int mining_slow_counter_ = 0;  // counts fast ticks; fires slow refresh every N
@@ -604,11 +626,17 @@ private:
     void applyDefaultBanlist();
 
     // Private methods - data refresh
-    void refreshData();
-    void refreshBalance();
-    void refreshAddresses();
+    void refreshData();           // Orchestrator: dispatches per-category refreshes
+    void refreshCoreData();       // Balance + blockchain info (can use fast_worker_)
+    void refreshAddressData();    // Address lists + balances
+    void refreshTransactionData(); // Transaction list + z_viewtransaction enrichment
+    void refreshEncryptionState(); // Wallet encryption/lock state
+    void refreshBalance();        // Legacy: balance-only refresh (used by specific callers)
+    void refreshAddresses();      // Legacy: standalone address refresh
     void refreshPrice();
     void refreshWalletEncryptionState();
+    void applyRefreshPolicy(ui::NavPage page);
+    bool shouldRefreshTransactions() const;
     void checkAutoLock();
     void checkIdleMining();
 };