feat(sound): snapshot getter + volume-update event on SoundManager

Extends the snapshot pattern to the three audio volume levels (system /
furni / trax) so volume-slider widgets on the React client can subscribe
to a single source of truth via useSyncExternalStore.

API additions on ISoundManager:
- systemVolume / furniVolume getters (parity with the existing
  traxVolume getter)
- getVolumesSnapshot(): Readonly<ISoundVolumesSnapshot> with the same
  lazy-frozen + invalidation-on-change semantics as the user/session
  snapshots
- new ISoundVolumesSnapshot { system, furni, trax } interface

New event: NitroEventType.SOUND_VOLUMES_UPDATED. Dispatched only when
the incoming NitroSettingsEvent.SETTINGS_UPDATED actually changes one
of the three volumes (a no-op refresh stays quiet).

While in there, fixed a real bug: the previous implementation cached
`volumeFurniUpdated` / `volumeTraxUpdated` BEFORE writing the new
values, but read `castedEvent.volumeFurni` / `castedEvent.volumeTrax`
in their pre-division form — comparing percent (e.g. 75) against the
already-divided stored value (e.g. 0.75) — so the change check almost
always reported "updated" for a real settings push and never reported
"updated" if the percent matched the stored fraction by coincidence
(only 0/100 are stable). Updated check is now consistent (compare
fraction vs fraction) and also tracks systemVolume changes for the
new snapshot invalidation.

packages/sound/src/SoundManager.ts

@@ -1,6 +1,6 @@
-import { IAdvancedMap, IMusicController, INitroEvent, ISoundManager } from '@nitrots/api';
+import { IAdvancedMap, IMusicController, INitroEvent, ISoundManager, ISoundVolumesSnapshot } from '@nitrots/api';
 import { GetConfiguration } from '@nitrots/configuration';
-import { GetEventDispatcher, NitroSettingsEvent, NitroSoundEvent, RoomEngineEvent, RoomEngineObjectEvent, RoomEngineSamplePlaybackEvent } from '@nitrots/events';
+import { GetEventDispatcher, NitroEvent, NitroEventType, NitroSettingsEvent, NitroSoundEvent, RoomEngineEvent, RoomEngineObjectEvent, RoomEngineSamplePlaybackEvent } from '@nitrots/events';
 import { AdvancedMap, NitroLogger } from '@nitrots/utils';
 import { MusicController } from './music/MusicController';
 
@@ -9,6 +9,7 @@ export class SoundManager implements ISoundManager
     private _volumeSystem: number = 0.5;
     private _volumeFurni: number = 0.5;
     private _volumeTrax: number = 0.5;
+    private _volumesSnapshot: Readonly<ISoundVolumesSnapshot> | null = null;
 
     private _internalSamples: IAdvancedMap<string, HTMLAudioElement> = new AdvancedMap();
     private _furniSamples: IAdvancedMap<number, HTMLAudioElement> = new AdvancedMap();
@@ -81,17 +82,24 @@ export class SoundManager implements ISoundManager
             case NitroSettingsEvent.SETTINGS_UPDATED: {
                 const castedEvent = (event as NitroSettingsEvent);
 
-                const volumeFurniUpdated = castedEvent.volumeFurni !== this._volumeFurni;
-                const volumeTraxUpdated = castedEvent.volumeTrax !== this._volumeTrax;
+                const nextSystem = (castedEvent.volumeSystem / 100);
+                const nextFurni = (castedEvent.volumeFurni / 100);
+                const nextTrax = (castedEvent.volumeTrax / 100);
 
-                this._volumeSystem = (castedEvent.volumeSystem / 100);
-                this._volumeFurni = (castedEvent.volumeFurni / 100);
-                this._volumeTrax = (castedEvent.volumeTrax / 100);
+                const volumeSystemUpdated = nextSystem !== this._volumeSystem;
+                const volumeFurniUpdated = nextFurni !== this._volumeFurni;
+                const volumeTraxUpdated = nextTrax !== this._volumeTrax;
+
+                this._volumeSystem = nextSystem;
+                this._volumeFurni = nextFurni;
+                this._volumeTrax = nextTrax;
 
                 if(volumeFurniUpdated) this.updateFurniSamplesVolume(this._volumeFurni);
 
                 if(volumeTraxUpdated) this._musicController?.updateVolume(this._volumeTrax);
 
+                if(volumeSystemUpdated || volumeFurniUpdated || volumeTraxUpdated) this.invalidateVolumesSnapshot();
+
                 return;
             }
             case NitroSoundEvent.PLAY_SOUND: {
@@ -215,8 +223,38 @@ export class SoundManager implements ISoundManager
         return this._volumeTrax;
     }
 
+    public get systemVolume(): number
+    {
+        return this._volumeSystem;
+    }
+
+    public get furniVolume(): number
+    {
+        return this._volumeFurni;
+    }
+
     public get musicController(): IMusicController
     {
         return this._musicController;
     }
+
+    private invalidateVolumesSnapshot(): void
+    {
+        this._volumesSnapshot = null;
+
+        GetEventDispatcher().dispatchEvent(new NitroEvent(NitroEventType.SOUND_VOLUMES_UPDATED));
+    }
+
+    public getVolumesSnapshot(): Readonly<ISoundVolumesSnapshot>
+    {
+        if(this._volumesSnapshot) return this._volumesSnapshot;
+
+        this._volumesSnapshot = Object.freeze<ISoundVolumesSnapshot>({
+            system: this._volumeSystem,
+            furni: this._volumeFurni,
+            trax: this._volumeTrax
+        });
+
+        return this._volumesSnapshot;
+    }
 }