- Add [PlayerName] prefix to all server message log lines
  (group/update, server/state, server/command) for multi-player
  diagnostics
- Log group ID and name changes in HandleGroupUpdate to help
  diagnose grouping issues
- Simplify SendPlayerStateAckAsync: remove redundant try/catch
  wrapper (exceptions already handled by SafeFireAndForget)
- Clean up comments to match actual protocol behavior

Trigger HandleConnectionLostAsync from failed sends when WebSocket is
closed but receive loop hasn't detected it yet. This fixes players
getting stuck in Connected state after server disappears.

Also: extract handshake into reusable SendHandshakeAsync, add
re-handshake on reconnection, stop time sync on Reconnecting state,
and fix ConnectInternalAsync to not transition through Disconnected
during AutoReconnect retries.

This commit addresses critical thread-safety issues identified during code review
that could cause duplicate reconnection attempts and unpredictable behavior,
especially in multi-player scenarios like multiSendSpin.

Race condition fixes:

- Remove _isReconnecting field and use e.OldState instead
  The _isReconnecting field was accessed without synchronization from multiple
  threads (receive loop, main thread, reconnect loop). Now we check
  e.OldState == ConnectionState.Reconnecting directly in the event args,
  which is immutable and thread-safe.

- Add Interlocked guard to HandleConnectionLostAsync
  Both send failure detection and the receive loop could trigger
  HandleConnectionLostAsync simultaneously when a connection dies.
  The atomic guard ensures only the first caller proceeds, preventing
  duplicate reconnection attempts and state machine corruption.

Additional improvements:

- Add CancellationToken support to PerformReconnectHandshakeAsync
  Allows graceful cancellation of reconnection handshakes during shutdown.

- Remove duplicate _clockSynchronizer.Reset() call
  HandleServerHello already resets the clock synchronizer when handshake
  completes, making the reset in PerformReconnectHandshakeAsync redundant.

- Revert routine group/update log level to Debug
  Keep routine state logs at Debug level per CLAUDE.md guidelines.
  Only actual state changes (group ID/name changes) remain at Information.

- Use SafeFireAndForget for TimeSyncLoopAsync
  Ensures any exceptions from the time sync loop are properly logged
  instead of being silently discarded with a bare discard assignment.

Add per-player logging and fix connection loss detection

Bug fix: When a track finished playing, the UI showed stuck at final position
(e.g., 4:21/4:21 with pause button) instead of updating properly.

Root cause: The metadata merge used null-coalescing (meta.Progress ?? existing)
which couldn't distinguish "field absent" (partial update) from "field is null"
(track ended). JSON has three states but C# nullable has only two.

Solution: Added Optional<T> type that tracks whether a JSON field was present,
matching the CLI's UndefinedField pattern in Python.

SDK changes:
- Add Optional<T> struct and OptionalJsonConverterFactory
- ServerMetadata.Progress now uses Optional<PlaybackProgress?>
- HandleServerState uses IsPresent check instead of null-coalescing

App changes:
- MainViewModel handles cleared progress by stopping interpolation
- Keep final position visible; PlaybackState change updates play/pause button

Clock sync offset/drift measurements are internal implementation details
useful for debugging timing issues, not routine operational info. Reduces
log noise in production environments.

SDK 6.1.1:
- Changed clock sync telemetry from Information to Debug log level
- Reduces log noise in production environments

In VMs, wall clock timers (Stopwatch/QPC) can jump erratically due to
hypervisor scheduling, causing fake sync errors and unnecessary audio
corrections. This adds a MonotonicTimer wrapper that:

- Enforces monotonicity (never returns decreasing values)
- Clamps forward jumps to 50ms max per callback
- Filters timer noise while preserving real DAC drift detection

The wrapper is enabled by default in AudioPipeline, making all SDK
consumers automatically VM-resilient without code changes.

Add MonotonicTimer for VM-resilient timing