fix(layers): keep nested groups in order and movable inside their parent (#1744)

* fix(layers): keep nested groups in order and movable inside their parent

The #1739 fix gave every empty folder a position, but derived it from the
nearest group in array order and, for a nested folder, from the end of its
parent's range. Neither reads as a sibling, so as soon as one child of a
group gained a layer its sibling folders were placed against the wrong
block: a nested folder could be pushed past an unrelated top-level group
and out of the parent it belongs to, and "move up"/"move down" on a nested
group reported a change while the panel snapped straight back.

Panel order now anchors an unpositioned group on its *siblings* — the
groups sharing its parent — whose ranges span their whole subtrees. An
ancestor's range already contains the slot being chosen and an unrelated
group's covers a different branch, so neither can place it; with no
sibling positioned yet a nested folder falls to the end of its parent's
block and a top-level one to the top of the panel.

Reordering follows the same shape: a group steps over a whole neighbouring
sibling block instead of one unit at a time into it, and the edge of its
parent is a wall, so a nested group moves among its siblings only and the
menu greys out at the first and last child. A top-level group now clears
a neighbouring subtree in one move rather than landing inside it.

Group headers all come from one core walk (layerPanelGroupHeaders,
replacing placeUnpositionedGroups), so the group a row belongs to, the
organizers above it, and the empty folders are emitted parents-first
against the same anchors. That is what keeps a nested folder below the
parent it sits in, and it drops the panel's duplicate anchor logic.

* Address CodeRabbit review feedback

- Correct the reorder docs about the parent boundary. CodeRabbit read
  moveGroupThroughUnits as letting a nested group move across layers its
  parent owns directly, and proposed rejecting that move. The observation
  is right but the move is not a defect: those rows are one more block
  inside the parent, so ordering a child against them is a real reorder,
  and the group still cannot cross the parent's boundary. Rejecting it
  would leave no way to order a child folder against its parent's own
  layers. What was wrong was the docstring, which claimed the parent's own
  rows end the travel; it now describes the boundary as the wall and notes
  that an empty folder is the one case that cannot cross layer rows,
  matching the limit empty folders already have at the top level.
- Pin both behaviours with regression tests: a populated child steps over
  its parent's own layers and then stops at an unrelated top-level group,
  and an empty child reports no move when only layer rows are adjacent.

* Address Claude review feedback

- Add automated coverage at two levels of nesting, which the earlier tests
  did not reach: a grandchild folder placed by its own sibling rather than
  by either ancestor, the full ancestor-first header chain drawn against
  one layer row, and a grandchild moving among its siblings with its own
  parent (not the outer group) as the wall. branchUnder's ancestor walk
  and the sibling-anchoring loop are the parts that could regress at depth
  2 without a test noticing.

Author: giswqs

apps/geolibre-desktop/src/components/panels/LayerPanel.tsx

@@ -32,7 +32,7 @@ import {
   excludeHiddenFieldsFromGeojson,
   layerGroupDepth,
   layerGroupMoveability,
-  placeUnpositionedGroups,
+  layerPanelGroupHeaders,
 } from "@geolibre/core";
 import type { EllipsoidId, GeoLibreLayer, LayerGroup } from "@geolibre/core";
 import type { FeatureCollection } from "geojson";
@@ -920,56 +920,14 @@ export function LayerPanel({
       }),
     [groupById, layerGroups],
   );
-  const firstMemberIdByGroup = useMemo(() => {
-    const map = new Map<string, string>();
-    for (const layer of visibleLayers) {
-      if (layer.groupId && !map.has(layer.groupId)) {
-        map.set(layer.groupId, layer.id);
-      }
-    }
-    return map;
-  }, [visibleLayers]);
-  const descendantLayerAnchorByGroup = useMemo(() => {
-    const result = new Map<string, string>();
-    const displayGroupIds = visibleLayers
-      .map((layer) => layer.groupId)
-      .filter((id): id is string => Boolean(id && groupById.has(id)));
-    for (const group of layerGroups) {
-      if (firstMemberIdByGroup.has(group.id)) continue;
-      const anchor = displayGroupIds.find((candidateId) => {
-        let parentId = groupById.get(candidateId)?.parentId;
-        const visited = new Set<string>();
-        while (parentId && !visited.has(parentId)) {
-          if (parentId === group.id) return true;
-          visited.add(parentId);
-          parentId = groupById.get(parentId)?.parentId;
-        }
-        return false;
-      });
-      if (anchor) result.set(group.id, anchor);
-    }
-    return result;
-  }, [firstMemberIdByGroup, groupById, layerGroups, visibleLayers]);
-  const organizerHeadersByAnchor = useMemo(() => {
-    const result = new Map<string, LayerGroup[]>();
-    for (const group of layerGroups) {
-      const anchor = descendantLayerAnchorByGroup.get(group.id);
-      if (!anchor) continue;
-      const headers = result.get(anchor) ?? [];
-      headers.push(group);
-      result.set(anchor, headers);
-    }
-    for (const headers of result.values()) {
-      headers.sort((a, b) => groupDepth(a) - groupDepth(b));
-    }
-    return result;
-  }, [descendantLayerAnchorByGroup, groupDepth, layerGroups]);
-  // Empty folders have no member to anchor them, so the core places them
-  // against their neighbours in the group order instead: a folder keeps its
-  // spot relative to the other folders when one of them gains a layer, and it
-  // can still be reordered (GeoLibre#1739).
-  const unpositionedGroups = useMemo(
-    () => placeUnpositionedGroups(layers, layerGroups),
+  // Every group header — the group a row belongs to, the organizers above it
+  // whose layers all live in child groups, and the folders holding no layer at
+  // all — comes from one core walk, anchored to the layer row it is drawn
+  // above. Deriving them together is what keeps a nested folder below the
+  // parent it sits in, and lets an empty folder keep its spot relative to its
+  // siblings when one of them gains a layer (GeoLibre#1739).
+  const groupHeaders = useMemo(
+    () => layerPanelGroupHeaders(layers, layerGroups),
     [layers, layerGroups],
   );
   const groupMoveability = useMemo(
@@ -2939,7 +2897,6 @@ export function LayerPanel({
           )}
           {visibleLayers.map((layer, displayIndex) => {
             const group = layer.groupId ? groupById.get(layer.groupId) : undefined;
-            const isFirstOfGroup = group ? firstMemberIdByGroup.get(group.id) === layer.id : false;
             const groupCollapsed = group?.collapsed ?? false;
             const groupAncestorCollapsed = group ? hasCollapsedAncestor(group) : false;
             // When an ancestor group is hidden, a layer whose own visibility
@@ -3102,17 +3059,9 @@ export function LayerPanel({
             const moveIds = selectedMoveIds(layer.id);
             return (
               <Fragment key={layer.id}>
-                {unpositionedGroups.aboveLayer.get(layer.id)?.map((empty) => (
-                  <Fragment key={empty.id}>{renderGroupHeader(empty)}</Fragment>
+                {groupHeaders.aboveLayer.get(layer.id)?.map((header) => (
+                  <Fragment key={header.id}>{renderGroupHeader(header)}</Fragment>
                 ))}
-                {isFirstOfGroup &&
-                  group &&
-                  organizerHeadersByAnchor
-                    .get(group.id)
-                    ?.map((organizer) => (
-                      <Fragment key={organizer.id}>{renderGroupHeader(organizer)}</Fragment>
-                    ))}
-                {isFirstOfGroup && group && renderGroupHeader(group)}
                 {!groupCollapsed && !groupAncestorCollapsed && (
                   <div
                     data-layer-card=""
@@ -4016,9 +3965,9 @@ export function LayerPanel({
               </Fragment>
             );
           })}
-          {/* Folders placed below the last layer row: the panel has no layer
+          {/* Headers placed below the last layer row: the panel has no layer
               left to anchor them above. */}
-          {unpositionedGroups.bottom.map((group) => (
+          {groupHeaders.bottom.map((group) => (
             <Fragment key={group.id}>{renderGroupHeader(group)}</Fragment>
           ))}
           <div