refactor: phases 5 & 6 — TransferService, Result<T>, RAII

Phase 5 — TransferService extraction:
- New nxst::TransferService owns all sender/receiver state, threads, and atomics
  (previously 11 file-statics across transfer_sender.cpp + transfer_receiver.cpp)
- startReceive() calls io::restore internally; UI never touches infra/fs or infra/net
- TitlesLayout routes all transfer ops through mainApp->transfer
- g_currentUId removed from global scope; TitlesLayout::InitTitles(AccountUid)
- MainApplication gains transfer member; layout refs renamed to snake_case
- userAppExit() updated to cancel via service

Phase 6 — Result<T> + RAII:
- include/nxst/domain/result.hpp: 85-line tagged-union Result<T,E> + Result<void,E>
- include/nxst/infra/fs/handles.hpp: FsFileSystemHandle (auto fsFsClose),
  FileHandle (auto fclose) — eliminates manual close on every error path
- io::backup / io::restore return nxst::Result<std::string> (was tuple<bool,Result,string>)
- new u8[] + malloc in copyFile/restore replaced with std::vector<u8>
- NACP save-creation extracted to createSaveIfNeeded() helper in io.cpp

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

include/nxst/domain/result.hpp

@@ -0,0 +1,85 @@
+#pragma once
+#include <string>
+#include <utility>
+
+namespace nxst {
+
+template <class T, class E = std::string>
+class Result {
+    bool ok;
+    alignas(T) alignas(E) unsigned char storage[sizeof(T) > sizeof(E) ? sizeof(T) : sizeof(E)];
+
+    Result() = default;
+
+public:
+    static Result success(T val) {
+        Result res;
+        res.ok = true;
+        new (res.storage) T(std::move(val));
+        return res;
+    }
+
+    static Result failure(E err) {
+        Result res;
+        res.ok = false;
+        new (res.storage) E(std::move(err));
+        return res;
+    }
+
+    ~Result() {
+        if (ok) reinterpret_cast<T*>(storage)->~T();
+        else    reinterpret_cast<E*>(storage)->~E();
+    }
+
+    Result(const Result& other) : ok(other.ok) {
+        if (ok) new (storage) T(*reinterpret_cast<const T*>(other.storage));
+        else    new (storage) E(*reinterpret_cast<const E*>(other.storage));
+    }
+
+    Result(Result&& other) : ok(other.ok) {
+        if (ok) new (storage) T(std::move(*reinterpret_cast<T*>(other.storage)));
+        else    new (storage) E(std::move(*reinterpret_cast<E*>(other.storage)));
+    }
+
+    Result& operator=(const Result&) = delete;
+
+    bool     isOk()  const noexcept { return ok; }
+    const T& value() const { return *reinterpret_cast<const T*>(storage); }
+    const E& error() const { return *reinterpret_cast<const E*>(storage); }
+};
+
+// Specialisation for Result<void>
+template <class E>
+class Result<void, E> {
+    bool ok;
+    alignas(E) unsigned char storage[sizeof(E)];
+
+    Result() = default;
+
+public:
+    static Result success() { Result res; res.ok = true; return res; }
+
+    static Result failure(E err) {
+        Result res;
+        res.ok = false;
+        new (res.storage) E(std::move(err));
+        return res;
+    }
+
+    ~Result() { if (!ok) reinterpret_cast<E*>(storage)->~E(); }
+
+    Result(const Result& other) : ok(other.ok) {
+        if (!ok) new (storage) E(*reinterpret_cast<const E*>(other.storage));
+    }
+
+    Result(Result&& other) : ok(other.ok) {
+        if (!ok) new (storage) E(std::move(*reinterpret_cast<E*>(other.storage)));
+    }
+
+    Result& operator=(const Result&) = delete;
+
+    bool     isOk()  const noexcept { return ok; }
+    const E& error() const { return *reinterpret_cast<const E*>(storage); }
+};
+
+} // namespace nxst