fix(editable-layers): correct SelectionLayer polygon picking for elongated lassos

[llamington]

Summary

Fixes false-positive selection in SelectionLayer's polygon mode for elongated/diagonal/concave lassos by replacing the GPU-pick + buffered-blocker mechanism with a CPU point-in-polygon test.

The bug

When using SelectionLayer({selectionType: 'polygon', ...}), pins that sit outside the drawn lasso are returned in onSelect({pickingInfos}) as if they were inside. The failure is reliable for any lasso whose bounding box extends more than ~50 km past its own edges — long thin lassos, diagonal lassos, and concave shapes.

Repro

1. Render a ScatterplotLayer of pins spread across a continent (e.g. the existing Manhattan demo, but at a wider zoom).
2. Add a SelectionLayer with selectionType: 'polygon'.
3. Draw a long thin lasso diagonally across the map.
4. Inspect onSelect({pickingInfos}): pins clearly outside the drawn polygon are included.

Root cause

_selectPolygonObjects does this:

1. Builds a "blocker" polygon — a turfBuffer(lasso, EXPANSION_KM = 50) polygon with the lasso subtracted (turfDifference).
2. Calls deck.pickObjects({bbox: lassoBoundingBox, layerIds: [blockerId, ...layerIds]}) after a setTimeout(250) for the blocker to render.
3. Filters the picks.

The blocker is what's meant to mask out pins outside the polygon. But:

• The buffer is fixed at 50 km. Any lasso whose bbox extends >50 km past its edges has gaps where the blocker doesn't cover, and pins in those gaps get picked even though they're outside the lasso polygon.
• The setTimeout(250) is a race; the source acknowledges it: // HACK, find a better way (line 139).
• The picking framebuffer also drops overlapping pins at the same pixel (related issue, nebula.gl#297).

nebula.gl#132 ("Fix concave lasso select bug") has been open since 2018 with a noted TODO: "more proper implementation than the setTimeout hack." This PR is that implementation.

The fix

Replace the GPU-pick + blocker mechanism with a direct CPU point-in-polygon test:

1. Take the drawn polygon coordinates.
2. For every layer named in layerIds, iterate its data.
3. Resolve each datum's position via layer.props.getPosition(...), with object.position / object.coordinates fallbacks.
4. Run @turf/boolean-point-in-polygon (already a dependency) against the polygon.
5. Emit a pickingInfo {object, layer, index} for each match.

The result is exact, synchronous, and free of the buffer, framebuffer, and timing constraints.

Scope

The new implementation supports layers exposing per-datum positions — ScatterplotLayer, IconLayer, TextLayer, ColumnLayer, etc. This matches:

• The layer type in the docs example (ScatterplotLayer).
• The layer type in examples/editable-layers/sf/app.tsx and examples/editable-layers/advanced/src/example.tsx (EditableGeoJsonLayer).

The previous implementation incidentally returned pickingInfos for PathLayer / PolygonLayer / ArcLayer via GPU picking, but the results were never meaningful — the 50 km blocker meant the lasso shape barely applied to those geometries anyway. Polygon-mode support for non-point layers was never documented, and no example demonstrates it. If maintainers want explicit support later, that's a separate feature with its own UX decisions (intersection vs containment for paths, etc.).

[charlieforward9]

non-geo may not all pass this conditional check

This works better than the current approach, so its not blocking, but these instances of turf should be triaged under a more careful pass - which may have been the original intention of the GPU-based selections?

CC @eKerney

[charlieforward9]

Would we want to extract a 3D position here for any reason? @felixpalmer