Crash handler polish (#4867)

#### Summary
Architectural cleanup and hardening of the Crash Handler. 
* Unifies DbgHelp symbol lifecycle by replacing fragmented
`SymInitialize`/`SymCleanup` calls with a shared
`CrashHandler::InitializeSymbolHandler()`.
* Deduplicates WER (Windows Error Reporting) registry setup by moving
canonical ownership entirely to the loader.
* Removes redundant classification and double-logging in
`CCrashDumpWriter::HandleExceptionGlobal`.
* Replaces a dangerous `TerminateThread` call in the watchdog with clean
abandonment to prevent CRT lock deadlocks during shutdown.

#### Motivation
This is a follow-up architectural polish to the recent crash handler
fixes. It resolves technical debt around overlapping symbol management
across `CrashHandler`, `CCrashDumpWriter`, and
`CExceptionInformation_Impl`, centralizes WER setup, and hardens the
shutdown sequence against deadlocks.

#### Test plan
1. Compiled and ran successfully.
2. Verified that MTA launches without regression. 
3. **To verify**: Trigger a crash and confirm that `mta/dumps/private`
still correctly populates with dumps, and that `core.log` still
successfully resolves symbols in the stack trace.

#### Checklist

* [x] Your code should follow the [coding
guidelines](https://wiki.multitheftauto.com/index.php?title=Coding_guidelines).
* [x] Smaller pull requests are easier to review. If your pull request
is beefy, your pull request should be reviewable commit-by-commit.

Author: Zephkek

Client/core/CCrashDumpWriter.cpp

@@ -282,62 +282,8 @@ static bool InvokeClientHandleExceptionSafe(CClientBase* pClient, CExceptionInfo
 
 namespace
 {
-    void ConfigureDbgHelpOptions()
-    {
-        static std::atomic_flag configured = ATOMIC_FLAG_INIT;
-        if (!configured.test_and_set(std::memory_order_acq_rel))
-        {
-            SymSetOptions(SYMOPT_LOAD_LINES | SYMOPT_UNDNAME | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_DEFERRED_LOADS);
-        }
-    }
-
-    std::mutex& GetSymInitMutex()
-    {
-        static std::mutex symMutex;
-        return symMutex;
-    }
 }  // namespace
 
-class SymbolHandlerGuard
-{
-public:
-    explicit SymbolHandlerGuard(HANDLE process, bool enableSymbols) : m_process(process), m_initialized(false)
-    {
-        if (!enableSymbols)
-            return;
-
-        if (m_process != nullptr)
-        {
-            std::lock_guard<std::mutex> lock{GetSymInitMutex()};
-
-            ConfigureDbgHelpOptions();
-
-            const SString& processDir = SharedUtil::GetMTAProcessBaseDir();
-            const char*    searchPath = processDir.empty() ? nullptr : processDir.c_str();
-
-            if (SymInitialize(m_process, searchPath, TRUE) != FALSE)
-                m_initialized = true;
-        }
-    }
-
-    ~SymbolHandlerGuard()
-    {
-        if (m_initialized)
-            SymCleanup(m_process);
-    }
-
-    SymbolHandlerGuard(const SymbolHandlerGuard&) = delete;
-    SymbolHandlerGuard& operator=(const SymbolHandlerGuard&) = delete;
-    SymbolHandlerGuard(SymbolHandlerGuard&&) = delete;
-    SymbolHandlerGuard& operator=(SymbolHandlerGuard&&) = delete;
-
-    bool IsInitialized() const { return m_initialized; }
-
-private:
-    HANDLE m_process;
-    bool   m_initialized;
-};
-
 [[nodiscard]] static bool NormalizePathForValidation(const SString& inputPath, SString& outputPath)
 {
     if (inputPath.empty())
@@ -767,9 +713,11 @@ static void AppendCrashDiagnostics(const SString& text)
     frame.AddrFrame.Mode = AddrModeFlat;
     frame.AddrStack.Mode = AddrModeFlat;
 
-    SymbolHandlerGuard symbolGuard(hProcess, hasSymbols);
-
-    const bool useDbgHelp = symbolGuard.IsInitialized();
+    bool useDbgHelp = false;
+    if (hasSymbols)
+    {
+        useDbgHelp = CrashHandler::InitializeSymbolHandler();
+    }
     const auto routines = useDbgHelp ? StackTraceHelpers::MakeStackWalkRoutines(true) : StackTraceHelpers::MakeStackWalkRoutines(false);
 
     static_assert(MAX_SYM_NAME > 1, "MAX_SYM_NAME must include room for a terminator");
@@ -1475,20 +1423,6 @@ long WINAPI CCrashDumpWriter::HandleExceptionGlobal(_EXCEPTION_POINTERS* pExcept
         return EXCEPTION_EXECUTE_HANDLER;
     }
 
-    if (IsFatalException(exceptionCode) == FALSE)
-    {
-        std::array<char, DEBUG_BUFFER_SIZE> szDebug;
-        SAFE_DEBUG_PRINT_C(szDebug.data(), szDebug.size(), "CCrashDumpWriter: Non-fatal exception 0x%08X - ignoring\n", exceptionCode);
-        ms_bInCrashHandler.store(false, std::memory_order_release);
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-
-    const BOOL exceptionLogged = LogExceptionDetails(pException);
-    if (exceptionLogged == FALSE)
-    {
-        SAFE_DEBUG_OUTPUT("CCrashDumpWriter: WARNING - LogExceptionDetails failed\n");
-    }
-
     SAFE_DEBUG_OUTPUT("CCrashDumpWriter: ======================================\n");
     SAFE_DEBUG_OUTPUT("CCrashDumpWriter: FATAL EXCEPTION - Begin crash processing\n");
     SAFE_DEBUG_OUTPUT("CCrashDumpWriter: ======================================\n");

Client/core/CExceptionInformation_Impl.cpp

@@ -129,59 +129,6 @@ struct StackFrameInfo
 };
 constexpr std::size_t MAX_FILE_NAME = 260;
 
-class SymbolHandlerGuard
-{
-public:
-    explicit SymbolHandlerGuard(HANDLE process, bool enableSymbols) : m_process(process), m_initialized(false), m_uncaughtExceptions(std::uncaught_exceptions())
-    {
-        if (!enableSymbols)
-        {
-            return;
-        }
-
-        if (m_process != nullptr)
-        {
-            SymSetOptions(SYMOPT_LOAD_LINES | SYMOPT_UNDNAME | SYMOPT_FAIL_CRITICAL_ERRORS);
-
-            if (SymInitialize(m_process, nullptr, TRUE) != FALSE)
-            {
-                m_initialized = true;
-            }
-            else
-            {
-                const DWORD dwError = GetLastError();
-                char        debugBuffer[DEBUG_BUFFER_SIZE] = {};
-                SAFE_DEBUG_PRINT_C(debugBuffer, DEBUG_BUFFER_SIZE, "%.*sSymbolHandlerGuard: SymInitialize failed, error: %u\n",
-                                   static_cast<int>(DEBUG_PREFIX_EXCEPTION_INFO.size()), DEBUG_PREFIX_EXCEPTION_INFO.data(), dwError);
-            }
-        }
-    }
-
-    ~SymbolHandlerGuard()
-    {
-        if (m_initialized)
-        {
-            if (std::uncaught_exceptions() <= m_uncaughtExceptions)
-            {
-                SymCleanup(m_process);
-            }
-            m_initialized = false;
-        }
-    }
-
-    SymbolHandlerGuard(const SymbolHandlerGuard&) = delete;
-    SymbolHandlerGuard& operator=(const SymbolHandlerGuard&) = delete;
-    SymbolHandlerGuard(SymbolHandlerGuard&&) = delete;
-    SymbolHandlerGuard& operator=(SymbolHandlerGuard&&) = delete;
-
-    bool IsInitialized() const { return m_initialized; }
-
-private:
-    HANDLE m_process;
-    bool   m_initialized;
-    int    m_uncaughtExceptions;
-};
-
 [[nodiscard]] static std::optional<std::vector<std::string>> CaptureEnhancedStackTrace(_EXCEPTION_POINTERS* pException)
 {
     if (pException == nullptr || pException->ContextRecord == nullptr)
@@ -214,9 +161,11 @@ class SymbolHandlerGuard
     frame.AddrFrame.Mode = AddrModeFlat;
     frame.AddrStack.Mode = AddrModeFlat;
 
-    SymbolHandlerGuard symbolGuard(hProcess, hasSymbols);
-
-    const bool useDbgHelp = symbolGuard.IsInitialized();
+    bool useDbgHelp = false;
+    if (hasSymbols)
+    {
+        useDbgHelp = CrashHandler::InitializeSymbolHandler();
+    }
 
     const auto                        routines = useDbgHelp ? StackTraceHelpers::MakeStackWalkRoutines(true) : StackTraceHelpers::MakeStackWalkRoutines(false);
     alignas(SYMBOL_INFO) std::uint8_t symbolBuffer[sizeof(SYMBOL_INFO) + MAX_SYMBOL_NAME];