Implement Task 4: Two-pass query execution for spatial filters

Added second-pass geometry refinement to eliminate false positives:

**Phase 1 (R-tree bbox search):**
- Fast bounding box search using R-tree index
- May include false positives (points in bbox corners)
- Changed from findContainedKeys to findIntersectingKeys for proper coverage

**Phase 2 (Geometry refinement):**
- Retrieves actual geometries from collection
- Uses precise JTS geometric operations (contains/covers/intersects)
- Eliminates false positives from bbox approximation

**Implementation details:**
- Added matchesGeometryFilter() for precise JTS validation
- Added getStoredGeometry() to retrieve documents by NitriteId
- Supports WithinFilter, GeoNearFilter, and IntersectsFilter
- Graceful error handling for invalid geometries

**Testing:**
- All 34 existing tests pass
- No breaking changes to existing functionality
- Two-pass execution transparent to users

This completes Task 4 from #1126, providing accurate spatial query results
without false positives from bounding box approximation.

Co-authored-by: anidotnet <696662+anidotnet@users.noreply.github.com>

Author: Copilot

nitrite-spatial/src/main/java/org/dizitart/no2/spatial/SpatialIndex.java

@@ -32,6 +32,7 @@
 import org.dizitart.no2.index.BoundingBox;
 import org.dizitart.no2.index.IndexDescriptor;
 import org.dizitart.no2.index.NitriteIndex;
+import org.dizitart.no2.store.NitriteMap;
 import org.dizitart.no2.store.NitriteRTree;
 import org.dizitart.no2.store.NitriteStore;
 import org.locationtech.jts.geom.Envelope;
@@ -131,29 +132,117 @@ public LinkedHashSet<NitriteId> findNitriteIds(FindPlan findPlan) {
             throw new FilterException("Spatial filter must be the first filter for index scan");
         }
 
-        RecordStream<NitriteId> keys;
+        // Phase 1: R-tree bounding box search (fast but may include false positives)
+        RecordStream<NitriteId> candidateKeys;
         NitriteRTree<BoundingBox, Geometry> indexMap = findIndexMap();
 
         SpatialFilter spatialFilter = (SpatialFilter) filter;
-        Geometry geometry = spatialFilter.getValue();
-        BoundingBox boundingBox = fromGeometry(geometry);
+        Geometry searchGeometry = spatialFilter.getValue();
+        BoundingBox boundingBox = fromGeometry(searchGeometry);
 
-        if (filter instanceof WithinFilter) {
-            keys = indexMap.findContainedKeys(boundingBox);
+        if (filter instanceof WithinFilter || filter instanceof GeoNearFilter) {
+            // For Within/Near filters, we want points that intersect the search geometry
+            // Note: We use intersecting here because we're searching for points WITHIN a circle
+            // The R-tree stores point bounding boxes, and we want those that overlap with
+            // the circle's bbox
+            candidateKeys = indexMap.findIntersectingKeys(boundingBox);
         } else if (filter instanceof IntersectsFilter) {
-            keys = indexMap.findIntersectingKeys(boundingBox);
+            candidateKeys = indexMap.findIntersectingKeys(boundingBox);
         } else {
             throw new FilterException("Unsupported spatial filter " + filter);
         }
 
-        LinkedHashSet<NitriteId> nitriteIds = new LinkedHashSet<>();
-        if (keys != null) {
-            for (NitriteId nitriteId : keys) {
-                nitriteIds.add(nitriteId);
+        LinkedHashSet<NitriteId> results = new LinkedHashSet<>();
+        if (candidateKeys == null) {
+            return results;
+        }
+
+        // Phase 2: Geometry refinement (precise filtering using actual JTS operations)
+        // This eliminates false positives from the bounding box approximation
+        for (NitriteId nitriteId : candidateKeys) {
+            if (matchesGeometryFilter(nitriteId, spatialFilter, searchGeometry)) {
+                results.add(nitriteId);
             }
         }
 
-        return nitriteIds;
+        return results;
+    }
+    
+    /**
+     * Performs precise geometry matching using JTS operations.
+     * This is the second pass that eliminates false positives from the R-tree bbox search.
+     * 
+     * @param nitriteId the document ID to check
+     * @param filter the spatial filter being applied
+     * @param searchGeometry the geometry to search with
+     * @return true if the stored geometry matches the filter criteria
+     */
+    private boolean matchesGeometryFilter(NitriteId nitriteId, SpatialFilter filter, Geometry searchGeometry) {
+        try {
+            // Retrieve the stored geometry for this document
+            Geometry storedGeometry = getStoredGeometry(nitriteId);
+            
+            if (storedGeometry == null) {
+                // If geometry is null, it matches only if the search is for null/empty
+                return searchGeometry == null;
+            }
+            
+            // Apply the appropriate JTS geometric operation based on filter type
+            if (filter instanceof WithinFilter || filter instanceof GeoNearFilter) {
+                // For Within and Near filters: the search geometry should contain the stored geometry
+                // OR the stored geometry should be within the search geometry
+                // For point-in-circle queries, we want to check if the point is within the circle
+                boolean result = searchGeometry.contains(storedGeometry) || searchGeometry.covers(storedGeometry);
+                return result;
+            } else if (filter instanceof IntersectsFilter) {
+                // For Intersects filter: geometries must intersect
+                return searchGeometry.intersects(storedGeometry);
+            }
+            
+            return false;
+        } catch (Exception e) {
+            // If there's an error (e.g., invalid geometry), exclude this result
+            return false;
+        }
+    }
+    
+    /**
+     * Retrieves the stored geometry from the collection for a given document ID.
+     * 
+     * @param nitriteId the document ID
+     * @return the stored geometry, or null if not found
+     */
+    private Geometry getStoredGeometry(NitriteId nitriteId) {
+        try {
+            // Get the collection map name from the index descriptor
+            String collectionName = indexDescriptor.getCollectionName();
+            
+            // Open the collection's document map
+            NitriteMap<NitriteId, Document> documentMap = 
+                nitriteStore.openMap(collectionName, NitriteId.class, Document.class);
+            
+            // Retrieve the document
+            Document document = documentMap.get(nitriteId);
+            if (document == null) {
+                return null;
+            }
+            
+            // Get the field name from the index descriptor
+            Fields fields = indexDescriptor.getFields();
+            List<String> fieldNames = fields.getFieldNames();
+            if (fieldNames.isEmpty()) {
+                return null;
+            }
+            
+            String fieldName = fieldNames.get(0);
+            Object fieldValue = document.get(fieldName);
+            
+            // Parse the geometry from the field value
+            return parseGeometry(fieldName, fieldValue);
+        } catch (Exception e) {
+            // If there's an error retrieving the geometry, return null
+            return null;
+        }
     }
 
     private NitriteRTree<BoundingBox, Geometry> findIndexMap() {