fix(tsan): eliminate data race in WalMmapWriter move constructor

The open() factory started the background thread with a pointer to a
local WalMmapWriter, then returned it by value into expected<>.  The
move constructor raced with the bg thread: the thread accessed members
of the local while the move was transferring ownership.

Fix: defer bg thread start via bg_deferred_ flag.  open() sets the
flag instead of spawning the thread.  The move constructor (which
constructs the final destination object) starts the thread with a
stable `this` pointer.  Both move-ctor and move-assign handle the
deferred flag and reset it after starting the thread.

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

Author: Johnson-Ogundeji

include/signet/ai/wal_mapped_segment.hpp

@@ -362,18 +362,22 @@ class WalMmapWriter {
     WalMmapWriter& operator=(const WalMmapWriter&) = delete;
 
     WalMmapWriter(WalMmapWriter&& o) {
-        // Stop the source's background thread before transferring ownership
-        o.bg_stop_.store(true, std::memory_order_release);
-        o.bg_cv_.notify_all();
-        if (o.bg_thread_.joinable())
-            o.bg_thread_.join();
+        // If the source has a running bg thread, stop it before transferring.
+        // If bg_deferred_, the thread was never started — skip join.
+        if (!o.bg_deferred_) {
+            o.bg_stop_.store(true, std::memory_order_release);
+            o.bg_cv_.notify_all();
+            if (o.bg_thread_.joinable())
+                o.bg_thread_.join();
+        }
 
         opts_        = std::move(o.opts_);
         ring_        = std::move(o.ring_);
         active_idx_  = o.active_idx_;
         next_seq_    = o.next_seq_;
         next_seg_id_ = o.next_seg_id_;
         closed_      = o.closed_;
+        bg_deferred_ = false;
         bg_stop_.store(false, std::memory_order_release);
         if (!closed_ && !ring_.empty())
             bg_thread_ = std::thread(&WalMmapWriter::bg_worker, this);
@@ -385,18 +389,21 @@ class WalMmapWriter {
     WalMmapWriter& operator=(WalMmapWriter&& o) {
         if (this != &o) {
             (void)close();
-            // Stop source bg thread
-            o.bg_stop_.store(true, std::memory_order_release);
-            o.bg_cv_.notify_all();
-            if (o.bg_thread_.joinable())
-                o.bg_thread_.join();
+            // Stop source bg thread (unless deferred)
+            if (!o.bg_deferred_) {
+                o.bg_stop_.store(true, std::memory_order_release);
+                o.bg_cv_.notify_all();
+                if (o.bg_thread_.joinable())
+                    o.bg_thread_.join();
+            }
 
             opts_        = std::move(o.opts_);
             ring_        = std::move(o.ring_);
             active_idx_  = o.active_idx_;
             next_seq_    = o.next_seq_;
             next_seg_id_ = o.next_seg_id_;
             closed_      = o.closed_;
+            bg_deferred_ = false;
             bg_stop_.store(false, std::memory_order_release);
             if (!closed_ && !ring_.empty())
                 bg_thread_ = std::thread(&WalMmapWriter::bg_worker, this);
@@ -477,8 +484,10 @@ class WalMmapWriter {
         w.active_idx_ = 0;
         w.init_slot_header(*w.ring_[0]);
 
-        // Start background thread
-        w.bg_thread_ = std::thread(&WalMmapWriter::bg_worker, &w);
+        // Background thread is started by the move constructor to avoid a
+        // data race: starting the thread here would give it a pointer to the
+        // local `w`, which is about to be moved into expected<WalMmapWriter>.
+        w.bg_deferred_ = true;
 
         return w;
     }
@@ -877,6 +886,7 @@ class WalMmapWriter {
     int64_t                           next_seq_    = 0;
     uint64_t                          next_seg_id_ = 0;  // protected by bg_mutex_
     bool                              closed_      = false;
+    bool                              bg_deferred_ = false;  // bg thread start deferred until after move
 
     std::thread             bg_thread_;
     mutable std::mutex      bg_mutex_;