feat(M4): Windows WinForms client, TOFU identity pinning, VAD threshold + always-on mode

Core ABI extensions (voicecat.h):
- vc_list_channels / vc_list_users / vc_list_user_streams — pull-based snapshot getters
  for the channel-tree and user-list UI; session_model_mu_ guards cross-thread reads
- VC_EVENT_JOIN_RESULT / vc_join_channel — channel join with optional password
- VC_EVENT_SERVER_IDENTITY + vc_confirm_server_identity — TOFU gate that blocks io_thread_
  until the UI approves or rejects; pins TLS leaf-cert SHA-256 (not declared Ed25519)
- vc_get_server_identity_display — Ed25519 fingerprint for human-readable display only
- VC_INPUT_ALWAYS_ON = 2 in vc_input_mode — transmit unconditionally, no VAD gate
- vc_set_vad_threshold — live RMS threshold update (0.0–1.0); EnergyVadProcessor stores
  it atomically so the audio RT path reads without a lock

C++ implementation:
- SessionModel::apply_snapshot / apply_channel_event fixed to populate parent_id,
  password_protected, and max_users (were permanently zeroed)
- TlsContext::peer_cert_fingerprint — SHA-256 of peer leaf cert DER via mbedTLS
- TofuStore split into peek (read-only) + pin (write) so first-connect only persists
  after user approval; tofu_store_path in vc_config for per-user pin file location
- TcpAcceptor uses dual-stack IPv6+IPv4 fallback (fixes localhost → ::1 on Windows)
- windows-client CMake preset: Release shared DLL, static MinGW runtime, no tools/tests
- New C++ tests: test_channel_user_list_abi, test_tofu_flow (14/14 green)

Windows client (clients/windows/ — .NET 10 WinForms):
- VoiceCat.Interop: LibraryImport P/Invoke surface, UnmanagedCallersOnly callbacks,
  Channel<VoiceCatEvent> event delivery drained by 30ms WinForms Timer
- VoiceCat.App: ConnectDialog (saved servers, DPAPI password storage), ServerIdentity-
  Dialog (TOFU first-connect / mismatch warning), MainForm (channel TreeView, user
  ListBox, RichTextBox chat, voice controls, device pickers, VAD/PTT/always-on mode,
  per-user gain/mute/NR tuning, VAD sensitivity TrackBar, level meter ProgressBar)
- PttKeyCaptureDialog — focus-scoped PTT key capture (documented limitation)
- PerUserTuningDialog — real-time gain/mute/NR applied to all of a user's streams
- Accessibility: explicit AccessibleName/Description on every control, & mnemonics,
  Activity log ListBox as durable screen-reader record, AutomationNotification for
  curated live announcements

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

clients/windows/VoiceCat.Interop/Marshaling.cs

@@ -0,0 +1,90 @@
+using System.Runtime.InteropServices;
+
+// Shared "walk a native array of owned-struct entries, convert to managed records, free the
+// native list" pattern — identical shape for vc_device_list/vc_channel_list/vc_user_list/
+// vc_stream_summary_list (all core-allocated, caller-freed; see voicecat.h's doc comments on
+// each). The matching vc_free_*_list call happens INSIDE each ToManaged here, immediately
+// after the conversion, so callers never need to remember to free anything themselves.
+namespace VoiceCat.Interop;
+
+internal static class Marshaling
+{
+    public static List<DeviceInfo> ToManaged(ref VcDeviceListNative native)
+    {
+        var result = new List<DeviceInfo>((int)native.Count);
+        int size = Marshal.SizeOf<VcDeviceNative>();
+        for (nuint i = 0; i < native.Count; i++)
+        {
+            var raw = Marshal.PtrToStructure<VcDeviceNative>(native.Items + (int)i * size);
+            result.Add(new DeviceInfo(
+                Marshal.PtrToStringUTF8(raw.Id) ?? string.Empty,
+                Marshal.PtrToStringUTF8(raw.Name) ?? string.Empty,
+                raw.IsDefault != 0));
+        }
+        NativeMethods.vc_free_device_list(ref native);
+        return result;
+    }
+
+    public static List<ChannelInfo> ToManaged(ref VcChannelListNative native)
+    {
+        var result = new List<ChannelInfo>((int)native.Count);
+        int size = Marshal.SizeOf<VcChannelNative>();
+        for (nuint i = 0; i < native.Count; i++)
+        {
+            var raw = Marshal.PtrToStructure<VcChannelNative>(native.Items + (int)i * size);
+            result.Add(new ChannelInfo(
+                raw.Id,
+                raw.ParentId,
+                Marshal.PtrToStringUTF8(raw.Name) ?? string.Empty,
+                raw.PasswordProtected != 0,
+                raw.MaxUsers));
+        }
+        NativeMethods.vc_free_channel_list(ref native);
+        return result;
+    }
+
+    public static List<UserInfo> ToManaged(ref VcUserListNative native)
+    {
+        var result = new List<UserInfo>((int)native.Count);
+        int size = Marshal.SizeOf<VcUserNative>();
+        for (nuint i = 0; i < native.Count; i++)
+        {
+            var raw = Marshal.PtrToStructure<VcUserNative>(native.Items + (int)i * size);
+            result.Add(new UserInfo(
+                raw.Id,
+                Marshal.PtrToStringUTF8(raw.Nickname) ?? string.Empty,
+                raw.IsGuest != 0,
+                raw.ChannelId));
+        }
+        NativeMethods.vc_free_user_list(ref native);
+        return result;
+    }
+
+    public static List<StreamSummary> ToManaged(ref VcStreamSummaryListNative native)
+    {
+        var result = new List<StreamSummary>((int)native.Count);
+        int size = Marshal.SizeOf<VcStreamSummaryNative>();
+        for (nuint i = 0; i < native.Count; i++)
+        {
+            var raw = Marshal.PtrToStructure<VcStreamSummaryNative>(native.Items + (int)i * size);
+            result.Add(new StreamSummary(
+                raw.StreamId,
+                raw.Kind,
+                Marshal.PtrToStringUTF8(raw.Label) ?? string.Empty));
+        }
+        NativeMethods.vc_free_stream_summary_list(ref native);
+        return result;
+    }
+
+    public static AudioConfigInfo ToManaged(in VcAudioConfigNative native) => new(
+        native.Codec,
+        native.Mode != 0,
+        native.SampleRate,
+        native.BitrateBps,
+        native.FrameMs,
+        native.Application,
+        native.Fec != 0,
+        native.ExpectedPacketLoss,
+        native.Dtx != 0,
+        native.Complexity);
+}