test: let the migration settle H2's key type before the readers compare

The concurrent legacy-index test failed on all three Java 17 builds with
UnsupportedOperationException: Can not compare, from inside H2. That is
not the race #1309 fixed. H2's ObjectDataType settles its key type on
first use through an unsynchronized field and identity checks in
SerializedObjectType.compare, so sixteen threads making a fresh map's
first key comparison at once can each see a different type instance.
The code is identical in h2 2.4.240 and 2.5.250; 2.5.250 only made it
show up more often.

With one legacy id the migration never compared a key, so the readers
made the first comparison. Two ids make the migration's second put do
it, before any reader gets past the migration lock. 10/10 green on
2.5.250 here; still 3/3 red on the pre-#1309 sources.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: anidotnet

nitrite-mvstore-adapter/src/test/java/org/dizitart/no2/mvstore/NitriteMVStoreTest.java

@@ -34,8 +34,10 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
@@ -215,9 +217,14 @@ public void testConcurrentFirstReadOfALegacyIndexMigratesOnce() throws Exception
                 try {
                     final IndexDescriptor desc = new IndexDescriptor(IndexType.NON_UNIQUE,
                         Fields.withNames("a"), "c");
-                    final NitriteId id = NitriteId.createId(1L);
+                    // two ids, so the migration's second put is the composite map's first key
+                    // comparison: H2's ObjectDataType settles its key type on first use without
+                    // any synchronization, and sixteen readers making that first comparison at
+                    // once can fail inside H2 with "Can not compare" (h2 2.4.240 and 2.5.250)
+                    final Set<NitriteId> ids = new LinkedHashSet<>(Arrays.asList(
+                        NitriteId.createId(1L), NitriteId.createId(2L)));
                     store.openMap(deriveIndexMapName(desc), DBValue.class, ArrayList.class)
-                        .put(new DBValue("k"), new ArrayList<>(Collections.singletonList(id)));
+                        .put(new DBValue("k"), new ArrayList<>(ids));
 
                     final NitriteConfig config = mock(NitriteConfig.class);
                     doReturn(store).when(config).getNitriteStore();
@@ -237,7 +244,7 @@ public void testConcurrentFirstReadOfALegacyIndexMigratesOnce() throws Exception
                     }
                     start.countDown();
                     for (Future<Set<NitriteId>> read : reads) {
-                        assertEquals(Collections.singleton(id), read.get(5, TimeUnit.SECONDS));
+                        assertEquals(ids, read.get(5, TimeUnit.SECONDS));
                     }
                     assertFalse(store.hasMap(deriveIndexMapName(desc)));
                 } finally {