[AZ-503] Tile identity → UUIDv5 + integer UPSERT (foundation)

Foundation half of original AZ-503 (split during /autodev step 10 batch 2
on user choice; deferred work moved to AZ-505 with a Blocks link).

Adds deterministic tile identity (UUIDv5 over (z, x, y, source, flight_id))
shared cross-repo with gps-denied-onboard via the pinned TileNamespace
5b8d0c2e-7f1a-4d3b-9c5e-1f3a8e7d2b6c, switches the tiles UPSERT key from
floats to integers with per-flight separation, plumbs FlightId through
UavTileMetadata + handler, and writes UAV evidence to per-flight
on-disk directories so two flights at the same (z, x, y) coexist.

- Common: pure-C# RFC 9562 Uuidv5 (no third-party dep) + FlightId DTO
  field; 10 Python-reference unit vectors verify byte parity.
- DataAccess: migration 014 adds flight_id (uuid NULL), location_hash
  (uuid NOT NULL, backfilled via session-scoped pg_temp.uuidv5),
  content_sha256 (bytea NULL), legacy_id (uuid NULL = preserves
  pre-AZ-503 random id one cycle); drops idx_tiles_unique_location_source
  (AZ-484) and adds idx_tiles_unique_identity keyed on
  (tile_zoom, tile_x, tile_y, tile_size_meters, source,
   COALESCE(flight_id, '00000000-...'::uuid)) + idx_tiles_location_hash.
- TileRepository: ColumnList + UPSERT updated; id never updated on
  conflict (preserves AC-2 idempotence). UpdateAsync extended.
- Services: TileService and UavTileUploadHandler compute deterministic
  Id + LocationHash + ContentSha256 before insert; UAV file path
  becomes ./tiles/uav/{flight_id or 'none'}/{z}/{x}/{y}.jpg.
- Tests: Uuidv5Tests (10 reference vectors), UavTileFilePathTests
  (per-flight + anonymous paths), UavTileUploadHandlerTests (AC-2,
  AC-3, AC-7, AC-11 unit-level), UavUploadTests (AC-3 + AC-4
  integration: multi-flight DB coexistence with shared location_hash
  + distinct file_path; float-different lat/lon collapse to 1 row),
  MigrationTests (column shape, idx_tiles_unique_identity supersedes
  AZ-484 index, deterministic backfill).
- IntegrationTests project references Common to reuse Uuidv5 in raw
  SQL seeds.
- AZ-488 MultiSourceCoexistence seed fixed to populate location_hash
  (otherwise migration 014's NOT NULL constraint fails).

ACs covered: AC-1, AC-2, AC-3, AC-4, AC-7, AC-8, AC-11.
ACs deferred to AZ-505: AC-5, AC-6, AC-9, AC-10, AC-12.

Co-authored-by: Cursor <cursoragent@cursor.com>

SatelliteProvider.Tests/UavTileUploadHandlerTests.cs

@@ -56,7 +56,13 @@ public class UavTileUploadHandlerTests : IDisposable
         result.Response.Items[0].TileId.Should().NotBeNull();
         inserted.Should().HaveCount(1);
         inserted[0].Source.Should().Be(TileSourceConverter.ToWireValue(TileSource.Uav));
-        inserted[0].FilePath.Should().Contain(Path.Combine("uav", "18"));
+        // AZ-503: flight-anonymous upload (ValidMetadata has FlightId=null) uses the
+        // literal "none" segment between "uav" and the zoom directory.
+        inserted[0].FilePath.Should().Contain(Path.Combine("uav", "none", "18"));
+        inserted[0].LocationHash.Should().NotBe(Guid.Empty,
+            "AZ-503: location_hash must be deterministic UUIDv5(TILE_NAMESPACE, \"z/x/y\")");
+        inserted[0].ContentSha256.Should().NotBeNullOrEmpty(
+            "AZ-503 AC-7: content_sha256 must be persisted for every UAV upload");
         File.Exists(inserted[0].FilePath).Should().BeTrue();
     }
 
@@ -170,6 +176,74 @@ public class UavTileUploadHandlerTests : IDisposable
         result.EnvelopeError.Should().Contain("Invalid `metadata` JSON");
     }
 
+    [Fact]
+    public async Task HandleAsync_TwoFlightsSameCell_ProduceDistinctIdsAndPathsButSameLocationHash()
+    {
+        // Arrange — AZ-503 AC-3 + AC-11: two flights uploading the same (z, x, y).
+        var jpegA = UavTileImageFactory.CreateRandomJpeg();
+        var jpegB = UavTileImageFactory.CreateRandomJpeg();
+        var f1 = Guid.Parse("11111111-1111-1111-1111-111111111111");
+        var f2 = Guid.Parse("22222222-2222-2222-2222-222222222222");
+        var metaA = ValidMetadata() with { FlightId = f1 };
+        var metaB = ValidMetadata() with { FlightId = f2 };
+        var (handler, repo) = BuildHandler();
+        var inserted = new List<TileEntity>();
+        repo.Setup(r => r.InsertAsync(It.IsAny<TileEntity>()))
+            .ReturnsAsync((TileEntity e) => e.Id)
+            .Callback<TileEntity>(e => inserted.Add(e));
+
+        // Act
+        await handler.HandleAsync(
+            JsonSerializer.Serialize(new UavTileBatchMetadataPayload { Items = { metaA } }),
+            new List<UavUploadFile> { new("a.jpg", "image/jpeg", jpegA) });
+        await handler.HandleAsync(
+            JsonSerializer.Serialize(new UavTileBatchMetadataPayload { Items = { metaB } }),
+            new List<UavUploadFile> { new("b.jpg", "image/jpeg", jpegB) });
+
+        // Assert
+        inserted.Should().HaveCount(2);
+        inserted[0].FlightId.Should().Be(f1);
+        inserted[1].FlightId.Should().Be(f2);
+        inserted[0].Id.Should().NotBe(inserted[1].Id, "AC-3: per-flight rows must have distinct deterministic ids");
+        inserted[0].LocationHash.Should().Be(inserted[1].LocationHash,
+            "AC-3: both rows share the same location_hash because (z, x, y) is identical");
+        inserted[0].FilePath.Should().NotBe(inserted[1].FilePath,
+            "AC-11: per-flight on-disk paths must differ");
+        inserted[0].FilePath.Should().Contain(f1.ToString());
+        inserted[1].FilePath.Should().Contain(f2.ToString());
+        File.Exists(inserted[0].FilePath).Should().BeTrue();
+        File.Exists(inserted[1].FilePath).Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task HandleAsync_IdenticalUpload_ProducesIdenticalIdAndDeterministicContentSha()
+    {
+        // Arrange — AZ-503 AC-2 + AC-7: same inputs → same UUIDv5 + same SHA-256.
+        var jpeg = UavTileImageFactory.CreateRandomJpeg();
+        var meta = ValidMetadata() with { FlightId = Guid.Parse("33333333-3333-3333-3333-333333333333") };
+        var (handler, repo) = BuildHandler();
+        var inserted = new List<TileEntity>();
+        repo.Setup(r => r.InsertAsync(It.IsAny<TileEntity>()))
+            .ReturnsAsync((TileEntity e) => e.Id)
+            .Callback<TileEntity>(e => inserted.Add(e));
+
+        // Act
+        await handler.HandleAsync(
+            JsonSerializer.Serialize(new UavTileBatchMetadataPayload { Items = { meta } }),
+            new List<UavUploadFile> { new("first.jpg", "image/jpeg", jpeg) });
+        await handler.HandleAsync(
+            JsonSerializer.Serialize(new UavTileBatchMetadataPayload { Items = { meta } }),
+            new List<UavUploadFile> { new("second.jpg", "image/jpeg", jpeg) });
+
+        // Assert
+        inserted.Should().HaveCount(2);
+        inserted[0].Id.Should().Be(inserted[1].Id, "AC-2: identical inputs must produce identical deterministic ids");
+        inserted[0].LocationHash.Should().Be(inserted[1].LocationHash);
+        inserted[0].ContentSha256.Should().BeEquivalentTo(inserted[1].ContentSha256,
+            "AC-7: identical JPEG bodies must produce identical SHA-256 digests");
+        inserted[0].ContentSha256!.Length.Should().Be(32, "SHA-256 always produces 32 bytes");
+    }
+
     private (UavTileUploadHandler Handler, Mock<ITileRepository> Repo) BuildHandler(UavQualityConfig? quality = null)
     {
         var qualityConfig = quality ?? new UavQualityConfig();