fix: ParquetImporter detects duplicate column names before VortexWriter

Previously the first signal a caller got was VortexWriter's internal
uniqueness check, several stack frames removed from the real cause and
with no mention of which import or source file triggered it:

  java.lang.IllegalArgumentException: duplicate field name: A
      at io.github.dfa1.vortex.writer.VortexWriter.<init>(VortexWriter.java:164)
      at io.github.dfa1.vortex.parquet.ParquetImporter.importParquet(...)

checkNoDuplicateNames now runs right after the schema is built from the
Parquet columns, throwing a ParquetImporter-specific message naming the
duplicate(s) and the source file. Root cause is always the source
Parquet file's own schema (DType.Struct legitimately permits duplicate
names in memory; VortexWriter correctly enforces the file format's
uniqueness requirement) — this only improves error quality at the
import boundary, no auto-disambiguation.

Verified against the real repro (Raincloud's uk-price-paid slug, whose
source CSV lacked a header row so the Parquet conversion tool used the
first data row's values as column names):

  IllegalArgumentException: Parquet schema has duplicate column
  name(s): [A]; source file: .../uk-price-paid.parquet

Fixes #280.

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

Author: dfa1

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to **vortex-java** are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Fixed
+
+- `ParquetImporter` detects duplicate column names in the source Parquet schema and throws a clear message naming the duplicate(s) and the source file, instead of a confusing `VortexWriter` internal-invariant error several frames removed from the actual cause. ([f2c05e57](https://github.com/dfa1/vortex-java/commit/f2c05e57))
+
 ## [0.12.3] — 2026-07-19
 
 ### Added

parquet/src/main/java/io/github/dfa1/vortex/parquet/ParquetImporter.java

@@ -22,9 +22,12 @@
 import java.nio.file.StandardOpenOption;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashSet;
 import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /// Reads a Parquet file and writes a Vortex file.
 ///
@@ -71,6 +74,7 @@ public static void importParquet(Path parquetPath, Path vortexPath, ImportOption
                 names.add(ColumnName.of(col.name()));
                 types.add(mapDType(col));
             }
+            checkNoDuplicateNames(names, parquetPath);
             DType.Struct schema = new DType.Struct(names, types, false);
             long totalRows = parquet.getFileMetaData().numRows();
 
@@ -115,6 +119,20 @@ public static void importParquet(Path parquetPath, Path vortexPath, ImportOption
         }
     }
 
+    static void checkNoDuplicateNames(List<ColumnName> names, Path parquetPath) {
+        Set<ColumnName> seen = new HashSet<>();
+        Set<ColumnName> duplicates = new LinkedHashSet<>();
+        for (ColumnName name : names) {
+            if (!seen.add(name)) {
+                duplicates.add(name);
+            }
+        }
+        if (!duplicates.isEmpty()) {
+            throw new IllegalArgumentException(
+                    "Parquet schema has duplicate column name(s): " + duplicates + "; source file: " + parquetPath);
+        }
+    }
+
     static DType mapDType(ColumnSchema col) {
         boolean nullable = col.repetitionType() == RepetitionType.OPTIONAL;
         return switch (col.type()) {

parquet/src/test/java/io/github/dfa1/vortex/parquet/ParquetImporterTest.java

@@ -25,6 +25,7 @@
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 class ParquetImporterTest {
@@ -181,6 +182,35 @@ void unknownColumn_throws() {
         }
     }
 
+    @Nested
+    class DuplicateNames {
+
+        @Test
+        void noDuplicates_doesNotThrow() {
+            // Given — a, b, c are all distinct
+            List<ColumnName> names = List.of(ColumnName.of("a"), ColumnName.of("b"), ColumnName.of("c"));
+
+            // When / Then
+            assertThatCode(() -> ParquetImporter.checkNoDuplicateNames(names, Path.of("source.parquet")))
+                    .doesNotThrowAnyException();
+        }
+
+        @Test
+        void duplicateName_throwsWithNameAndSourcePath() {
+            // Given — two columns both named "A", as seen on the Raincloud uk-price-paid slug (#280): a
+            // headerless source CSV made a Parquet conversion tool use the first data row as column
+            // names, and two property-type flag columns happened to share the value "A".
+            List<ColumnName> names = List.of(ColumnName.of("A"), ColumnName.of("B"), ColumnName.of("A"));
+            Path source = Path.of("uk-price-paid.parquet");
+
+            // When / Then
+            assertThatThrownBy(() -> ParquetImporter.checkNoDuplicateNames(names, source))
+                    .isInstanceOf(IllegalArgumentException.class)
+                    .hasMessageContaining("A")
+                    .hasMessageContaining("uk-price-paid.parquet");
+        }
+    }
+
     @Nested
     class Import {