feat(audience): add ConsentStore for atomic consent persistence

Introduces Core/ConsentStore, a tiny static wrapper that reads and
writes the user's ConsentLevel to disk under
{persistentDataPath}/imtbl_audience/consent. Save uses the same
write-temp-then-move pattern as DiskStore and Identity so a crash
mid-write cannot leave a half-written consent level on disk; Load
returns null on missing, malformed, or unreadable files so callers
can fall back to the configured default.

No production callers yet. ImmutableAudience will consume this in
the next commit to persist SetConsent decisions across launches.

Tests/Runtime/Core/ConsentStoreTests covers the round-trip, the
null return for missing/corrupt/out-of-range files, and the
behaviour when the backing directory does not yet exist.

Author: ImmutableJeffrey

src/Packages/Audience/Runtime/Core/ConsentStore.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+
+namespace Immutable.Audience
+{
+    internal static class ConsentStore
+    {
+        internal static void Save(string persistentDataPath, ConsentLevel level)
+        {
+            Directory.CreateDirectory(AudiencePaths.AudienceDir(persistentDataPath));
+
+            var filePath = AudiencePaths.ConsentFile(persistentDataPath);
+            var tmpPath = filePath + ".tmp";
+
+            File.WriteAllText(tmpPath, ((int)level).ToString());
+
+            try
+            {
+                File.Move(tmpPath, filePath);
+            }
+            catch (IOException)
+            {
+                File.Delete(filePath);
+                File.Move(tmpPath, filePath);
+            }
+        }
+
+        // Returns null on missing/malformed/unreadable file; caller falls back to config default.
+        internal static ConsentLevel? Load(string persistentDataPath)
+        {
+            try
+            {
+                var filePath = AudiencePaths.ConsentFile(persistentDataPath);
+                if (!File.Exists(filePath)) return null;
+
+                var text = File.ReadAllText(filePath).Trim();
+                if (int.TryParse(text, out var raw) && Enum.IsDefined(typeof(ConsentLevel), raw))
+                    return (ConsentLevel)raw;
+            }
+            catch (IOException)
+            {
+            }
+            catch (UnauthorizedAccessException)
+            {
+            }
+
+            return null;
+        }
+    }
+}

src/Packages/Audience/Tests/Runtime/Core/ConsentStoreTests.cs

@@ -0,0 +1,70 @@
+using System.IO;
+using NUnit.Framework;
+
+namespace Immutable.Audience.Tests
+{
+    [TestFixture]
+    internal class ConsentStoreTests
+    {
+        private string _testDir;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _testDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
+            Directory.CreateDirectory(_testDir);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            if (Directory.Exists(_testDir))
+                Directory.Delete(_testDir, recursive: true);
+        }
+
+        [Test]
+        public void Load_NoFile_ReturnsNull()
+        {
+            Assert.IsNull(ConsentStore.Load(_testDir));
+        }
+
+        [Test]
+        public void SaveThenLoad_RoundtripsValue([Values] ConsentLevel level)
+        {
+            ConsentStore.Save(_testDir, level);
+            Assert.AreEqual(level, ConsentStore.Load(_testDir));
+        }
+
+        [Test]
+        public void Save_OverwritesPreviousValue()
+        {
+            ConsentStore.Save(_testDir, ConsentLevel.Anonymous);
+            ConsentStore.Save(_testDir, ConsentLevel.Full);
+
+            Assert.AreEqual(ConsentLevel.Full, ConsentStore.Load(_testDir));
+        }
+
+        [Test]
+        public void Load_MalformedFile_ReturnsNull()
+        {
+            // A garbage value that isn't a valid enum int.
+            var dir = AudiencePaths.AudienceDir(_testDir);
+            Directory.CreateDirectory(dir);
+            File.WriteAllText(AudiencePaths.ConsentFile(_testDir), "not-an-int");
+
+            Assert.IsNull(ConsentStore.Load(_testDir));
+        }
+
+        [Test]
+        public void Load_OutOfRangeIntInFile_ReturnsNull()
+        {
+            // 999 is parseable as int but not a defined ConsentLevel.
+            var dir = AudiencePaths.AudienceDir(_testDir);
+            Directory.CreateDirectory(dir);
+            File.WriteAllText(AudiencePaths.ConsentFile(_testDir), "999");
+
+            Assert.IsNull(ConsentStore.Load(_testDir));
+        }
+
+    }
+}