fix(logger): eliminate deadlock and data race in set_config()

FileLogger and UniqueFileLogger set_config() held m_mutex while calling
executor->wait(), but async tasks in those executors also acquire m_mutex
to perform write_log(). This caused a deadlock when a pending task tried
to lock m_mutex while set_config() was waiting for it under the same lock.

Additionally, set_config() did not take m_lifecycle_mutex, so log() could
read m_config/m_executor while they were being modified -> use-after-move /
data race.

Fix:
- set_config() now takes m_lifecycle_mutex first to serialize with log().
- executor->wait() is called WITHOUT holding m_mutex, removing the deadlock.
- FileLogger flushes m_file under a brief m_mutex scope after the wait.
- m_config/m_executor mutations remain under m_mutex for consistency.
- old_executor->shutdown() is still performed outside all locks.

Scope-risk: moderate (fixes a deadlock introduced in the same PR chain)
Confidence: high

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: LimiNode

include/logit_cpp/logit/loggers/FileLogger.hpp

@@ -211,28 +211,37 @@ namespace logit {
         void set_config(const Config& config) {
             std::unique_ptr<detail::SingleThreadExecutor> old_executor;
             {
-                std::unique_lock<std::mutex> lock(m_mutex);
+                std::lock_guard<std::mutex> lifecycle_lock(m_lifecycle_mutex);
                 if (m_shutdown.load(std::memory_order_acquire)) return;
+
                 if (m_config.async) {
                     if (m_executor) {
                         m_executor->wait();
                     } else {
                         detail::TaskExecutor::get_instance().wait();
                     }
+                    {
+                        std::lock_guard<std::mutex> lock(m_mutex);
+                        if (m_file.is_open()) m_file.flush();
+                    }
                 }
-                m_config.async = config.async;
-                m_config.use_dedicated_executor = config.use_dedicated_executor;
-                m_config.queue_capacity = config.queue_capacity;
-                m_config.queue_policy = config.queue_policy;
-                if (m_config.async && m_config.use_dedicated_executor) {
-                    if (!m_executor) {
-                        m_executor.reset(new detail::SingleThreadExecutor());
+
+                {
+                    std::lock_guard<std::mutex> lock(m_mutex);
+                    m_config.async = config.async;
+                    m_config.use_dedicated_executor = config.use_dedicated_executor;
+                    m_config.queue_capacity = config.queue_capacity;
+                    m_config.queue_policy = config.queue_policy;
+                    if (m_config.async && m_config.use_dedicated_executor) {
+                        if (!m_executor) {
+                            m_executor.reset(new detail::SingleThreadExecutor());
+                        }
+                        m_executor->set_max_queue_size(m_config.queue_capacity);
+                        m_executor->set_queue_policy(m_config.queue_policy);
+                    } else if (m_executor) {
+                        old_executor = std::move(m_executor);
+                        m_executor.reset();
                     }
-                    m_executor->set_max_queue_size(m_config.queue_capacity);
-                    m_executor->set_queue_policy(m_config.queue_policy);
-                } else if (m_executor) {
-                    old_executor = std::move(m_executor);
-                    m_executor.reset();
                 }
             }
             if (old_executor) {

include/logit_cpp/logit/loggers/UniqueFileLogger.hpp

@@ -158,28 +158,33 @@ namespace logit {
         void set_config(const Config& config) {
             std::unique_ptr<detail::SingleThreadExecutor> old_executor;
             {
-                std::unique_lock<std::mutex> lock(m_mutex);
+                std::lock_guard<std::mutex> lifecycle_lock(m_lifecycle_mutex);
                 if (m_shutdown.load(std::memory_order_acquire)) return;
+
                 if (m_config.async) {
                     if (m_executor) {
                         m_executor->wait();
                     } else {
                         detail::TaskExecutor::get_instance().wait();
                     }
                 }
-                m_config.async = config.async;
-                m_config.use_dedicated_executor = config.use_dedicated_executor;
-                m_config.queue_capacity = config.queue_capacity;
-                m_config.queue_policy = config.queue_policy;
-                if (m_config.async && m_config.use_dedicated_executor) {
-                    if (!m_executor) {
-                        m_executor.reset(new detail::SingleThreadExecutor());
+
+                {
+                    std::lock_guard<std::mutex> lock(m_mutex);
+                    m_config.async = config.async;
+                    m_config.use_dedicated_executor = config.use_dedicated_executor;
+                    m_config.queue_capacity = config.queue_capacity;
+                    m_config.queue_policy = config.queue_policy;
+                    if (m_config.async && m_config.use_dedicated_executor) {
+                        if (!m_executor) {
+                            m_executor.reset(new detail::SingleThreadExecutor());
+                        }
+                        m_executor->set_max_queue_size(m_config.queue_capacity);
+                        m_executor->set_queue_policy(m_config.queue_policy);
+                    } else if (m_executor) {
+                        old_executor = std::move(m_executor);
+                        m_executor.reset();
                     }
-                    m_executor->set_max_queue_size(m_config.queue_capacity);
-                    m_executor->set_queue_policy(m_config.queue_policy);
-                } else if (m_executor) {
-                    old_executor = std::move(m_executor);
-                    m_executor.reset();
                 }
             }
             if (old_executor) {