Refactor app services and stabilize refresh/UI flows

- Add refresh scheduler and network refresh service boundaries for typed
  refresh results, ordered RPC collectors, applicators, and price parsing.
- Add daemon lifecycle and wallet security workflow helpers while preserving
  App-owned command RPC, decrypt, cancellation, and UI handoff behavior.
- Split balance, console, mining, amount formatting, and async task logic into
  focused modules with expanded Phase 4 test coverage.
- Fix market price loading by triggering price refresh immediately, avoiding
  queue-pressure drops, tracking loading/error state, and adding translations.
- Polish send, explorer, peers, settings, theme/schema, and related tab UI.
- Replace checked-in generated language headers with build-generated resources.
- Document the cleanup audit, UI static-state guidance, and architecture updates.

src/daemon/daemon_controller.cpp

@@ -0,0 +1,117 @@
+#include "daemon_controller.h"
+#include "../config/settings.h"
+
+#include <algorithm>
+
+namespace dragonx {
+namespace daemon {
+
+DaemonController::DaemonController()
+    : daemon_(std::make_unique<EmbeddedDaemon>())
+{
+}
+
+DaemonController::~DaemonController() = default;
+
+void DaemonController::setStateCallback(StateCallback callback)
+{
+    daemon_->setStateCallback(std::move(callback));
+}
+
+void DaemonController::syncSettings(const config::Settings* settings)
+{
+    if (!settings) return;
+    daemon_->setDebugCategories(settings->getDebugCategories());
+    daemon_->setMaxConnections(settings->getMaxConnections());
+}
+
+bool DaemonController::start(const config::Settings* settings)
+{
+    syncSettings(settings);
+    return daemon_->start();
+}
+
+void DaemonController::stop(int waitMs)
+{
+    daemon_->stop(waitMs);
+}
+
+bool DaemonController::isRunning() const
+{
+    return daemon_->isRunning();
+}
+
+bool DaemonController::externalDaemonDetected() const
+{
+    return daemon_->externalDaemonDetected();
+}
+
+DaemonController::State DaemonController::state() const
+{
+    return daemon_->getState();
+}
+
+const std::string& DaemonController::lastError() const
+{
+    return daemon_->getLastError();
+}
+
+int DaemonController::crashCount() const
+{
+    return daemon_->getCrashCount();
+}
+
+int DaemonController::lastBlockHeight() const
+{
+    return daemon_ ? daemon_->getLastBlockHeight() : 0;
+}
+
+double DaemonController::memoryUsageMB() const
+{
+    return daemon_ ? daemon_->getMemoryUsageMB() : 0.0;
+}
+
+std::vector<std::string> DaemonController::recentLines(std::size_t count) const
+{
+    return daemon_ ? daemon_->getRecentLines(count) : std::vector<std::string>{};
+}
+
+std::string DaemonController::outputSince(std::size_t& offset) const
+{
+    return daemon_ ? daemon_->getOutputSince(offset) : std::string{};
+}
+
+void DaemonController::resetCrashCount()
+{
+    daemon_->resetCrashCount();
+}
+
+void DaemonController::setRescanOnNextStart(bool enabled)
+{
+    daemon_->setRescanOnNextStart(enabled);
+}
+
+bool DaemonController::rescanOnNextStart() const
+{
+    return daemon_->rescanOnNextStart();
+}
+
+void DaemonController::prepareLifecycleOperation(const LifecycleDecision& decision,
+                                                 const config::Settings* settings)
+{
+    if (settings) syncSettings(settings);
+    if (decision.resetCrashCount) resetCrashCount();
+    if (decision.setRescanOnNextStart) setRescanOnNextStart(true);
+}
+
+DaemonController::ShutdownDecision DaemonController::shutdownDecision(
+    bool keepDaemonRunning, bool stopExternalDaemon) const
+{
+    return evaluateShutdownPolicy(static_cast<bool>(daemon_),
+                                  daemon_ && daemon_->externalDaemonDetected(),
+                                  keepDaemonRunning,
+                                  stopExternalDaemon);
+}
+
+} // namespace daemon
+} // namespace dragonx