feat: RPC caching, background decrypt import, fast-lane peers, mining fix

RPC client:
- Add call() overload with per-call timeout parameter
- z_exportwallet uses 300s, z_importwallet uses 1200s timeout

Decrypt wallet (app_security.cpp, app.cpp):
- Show per-step and overall elapsed timers during decrypt flow
- Reduce dialog to 5 steps; close before key import begins
- Run z_importwallet on detached background thread
- Add pulsing "Importing keys..." status bar indicator
- Report success/failure via notifications instead of dialog

RPC caching (app_network.cpp, app.h):
- Cache z_viewtransaction results in viewtx_cache_ across refresh cycles
- Skip RPC calls for already-cached txids (biggest perf win)
- Build confirmed_tx_cache_ for deeply-confirmed transactions
- Clear all caches on disconnect
- Remove unused refreshTransactions() dead code

Peers (app_network.cpp, peers_tab.cpp):
- Route refreshPeerInfo() through fast_worker_ to avoid head-of-line blocking
- Replace footer "Refresh Peers" button with ICON_MD_REFRESH in toggle header
- Refresh button triggers both peer list and full blockchain data refresh

Mining (mining_tab.cpp):
- Allow pool mining toggle when blockchain is not synced
- Pool mining only needs xmrig, not local daemon sync

src/rpc/rpc_client.cpp

@@ -182,6 +182,65 @@ json RPCClient::call(const std::string& method, const json& params)
     return response["result"];
 }
 
+json RPCClient::call(const std::string& method, const json& params, long timeoutSec)
+{
+    std::lock_guard<std::recursive_mutex> lk(curl_mutex_);
+    if (!impl_->curl) {
+        throw std::runtime_error("Not connected");
+    }
+
+    // Temporarily override timeout
+    long prevTimeout = 30L;
+    curl_easy_setopt(impl_->curl, CURLOPT_TIMEOUT, timeoutSec);
+
+    try {
+        // Unlock before calling to avoid recursive lock issues — but we already hold it,
+        // and call() also locks with recursive_mutex, so just delegate to the body directly.
+        json payload = makePayload(method, params);
+        std::string body = payload.dump();
+        std::string response_data;
+
+        curl_easy_setopt(impl_->curl, CURLOPT_POSTFIELDS, body.c_str());
+        curl_easy_setopt(impl_->curl, CURLOPT_POSTFIELDSIZE, (long)body.size());
+        curl_easy_setopt(impl_->curl, CURLOPT_WRITEDATA, &response_data);
+
+        CURLcode res = curl_easy_perform(impl_->curl);
+
+        // Restore original timeout
+        curl_easy_setopt(impl_->curl, CURLOPT_TIMEOUT, prevTimeout);
+
+        if (res != CURLE_OK) {
+            throw std::runtime_error("RPC request failed: " + std::string(curl_easy_strerror(res)));
+        }
+
+        long http_code = 0;
+        curl_easy_getinfo(impl_->curl, CURLINFO_RESPONSE_CODE, &http_code);
+
+        if (http_code != 200) {
+            try {
+                json response = json::parse(response_data);
+                if (response.contains("error") && !response["error"].is_null()) {
+                    std::string err_msg = response["error"]["message"].get<std::string>();
+                    throw std::runtime_error(err_msg);
+                }
+            } catch (const json::exception&) {}
+            throw std::runtime_error("RPC error: HTTP " + std::to_string(http_code));
+        }
+
+        json response = json::parse(response_data);
+        if (response.contains("error") && !response["error"].is_null()) {
+            std::string err_msg = response["error"]["message"].get<std::string>();
+            throw std::runtime_error("RPC error: " + err_msg);
+        }
+
+        return response["result"];
+    } catch (...) {
+        // Ensure timeout is always restored
+        curl_easy_setopt(impl_->curl, CURLOPT_TIMEOUT, prevTimeout);
+        throw;
+    }
+}
+
 std::string RPCClient::callRaw(const std::string& method, const json& params)
 {
     std::lock_guard<std::recursive_mutex> lk(curl_mutex_);