refactor(audience): return Task from DeleteData (SDK-147)

DeleteData fires a backend DELETE for GDPR erasure but returned void,
so callers had no handle to know when the erasure completed or
failed. FlushAsync returns Task for the same reason - symmetrising
the lifecycle methods on the singleton.

- Public signature becomes `public static Task DeleteData(string
  userId = null)`.
- All early-return paths (not initialised, no config, no anonymousId)
  return Task.CompletedTask.
- The hot path's Task.Run is just returned directly instead of
  discarded. No change to the actual HTTP request, error surfacing,
  or anonymousId-file-side-effect-avoidance contract.
- Callers that want fire-and-forget still get it by ignoring the
  return value; callers that want to gate on completion can now
  await. Existing void-discarding call sites continue to compile.

Two new tests: awaited task completes after DELETE dispatch, and
the pre-Init guard returns Task.CompletedTask. 158 passing.

Linear: SDK-147

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ImmutableJeffrey

src/Packages/Audience/Runtime/ImmutableAudience.cs

@@ -228,14 +228,16 @@ public static void Reset()
             Identity.Reset(config.PersistentDataPath);
         }
 
-        // Ask the backend to erase this player's data.
-        public static void DeleteData(string userId = null)
+        // Ask the backend to erase this player's data. Returns a task the
+        // caller can await to know when the request is acknowledged, or
+        // discard for fire-and-forget.
+        public static Task DeleteData(string userId = null)
         {
-            if (!_initialized) return;
+            if (!_initialized) return Task.CompletedTask;
 
             var config = _config;
             var client = _controlClient;
-            if (config == null || client == null) return;
+            if (config == null || client == null) return Task.CompletedTask;
 
             string query;
             if (!string.IsNullOrEmpty(userId))
@@ -247,15 +249,15 @@ public static void DeleteData(string userId = null)
                 // Get, not GetOrCreate — a brand-new install must not register an ID just to delete it.
                 var anonymousId = Identity.Get(config.PersistentDataPath);
                 if (string.IsNullOrEmpty(anonymousId))
-                    return;
+                    return Task.CompletedTask;
                 query = "anonymousId=" + Uri.EscapeDataString(anonymousId);
             }
 
             var url = Constants.DataUrl(config.PublishableKey) + "?" + query;
             var onError = config.OnError;
             var publishableKey = config.PublishableKey;
 
-            Task.Run(async () =>
+            return Task.Run(async () =>
             {
                 try
                 {

src/Packages/Audience/Tests/Runtime/DeleteDataTests.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Threading;
@@ -144,6 +145,35 @@ public void DeleteData_DoesNotCreateAnonymousIdFile()
                 "DeleteData must not create the anonymousId file as a side effect");
         }
 
+        [Test]
+        public async Task DeleteData_ReturnsTask_ThatCompletesAfterRequest()
+        {
+            var handler = new CapturingHandler();
+            ImmutableAudience.Init(MakeConfig(handler));
+
+            var task = ImmutableAudience.DeleteData(userId: "player-42");
+            Assert.IsNotNull(task, "DeleteData must return a non-null Task");
+
+            // Await directly: no need for the RequestSent gate when the task
+            // already represents completion.
+            await task;
+
+            Assert.IsTrue(handler.Requests.Any(r => r.Method == HttpMethod.Delete),
+                "DELETE request must have been sent by the time the task completes");
+        }
+
+        [Test]
+        public void DeleteData_BeforeInit_ReturnsCompletedTask()
+        {
+            // Not initialised — must not throw, must return a completed Task.
+            ImmutableAudience.ResetState();
+
+            var task = ImmutableAudience.DeleteData(userId: "player-42");
+
+            Assert.IsNotNull(task);
+            Assert.IsTrue(task.IsCompleted, "DeleteData before Init must return an already-completed Task");
+        }
+
         [Test]
         public void DeleteData_ServerError_InvokesOnError()
         {