refactor(ls_tools): remove H1, H2, H4 heuristics — explicit annotation contract

Replace the three highest-value geometric heuristics in the Label Studio →
DoclingDocument pipeline with explicit annotation-driven lookups:

H1 (parent resolution via containment tree):
- Build `children_by_parent` dict from `parent_ls_id` on rectangle regions
- `_determine_parent` and `_has_unresolved_parent` become direct dict lookups
- Remove `build_containment_tree`, `ls_element_to_cvat_element`, `_find_tree_node`,
  `containment_tree`/`tree_index` fields, and CVATElement/TreeNode imports

H2 (table structure discovery via bbox containment):
- `_create_table` uses `children_by_parent.get(element.ls_id)` instead of tree walk
- Table structure elements still consumed geometrically by `compute_cells` (unchanged)

H4 (list boundary detection via level comparison):
- `should_terminate_list`: remove level-based fallback — group path is the only
  boundary signal; element outside active group terminates the list
- `shtart_list`: remove level-comparison block; warn on list_item with no group

H1 reading order (child paths):
- `build_global_reading_order` restructured with DFS splice: child paths
  (polyline `level > 1`) are spliced immediately after their parent element
- Validation warnings for mismatched parent_ls_id and level/path-type mismatches

H5 (_process_remaining_children) simplifies naturally:
- Elements with no `parent_ls_id` absent from reading order are dropped with a warning
  instead of silently added at root

Signed-off-by: Christoph Auer <cau@zurich.ibm.com>

Author: cau-git

docling_cvat_tools/ls_tools/list_hierarchy.py

@@ -123,31 +123,14 @@ def should_terminate_list(
         # No active list
         return False
 
-    # Check group-based termination
+    # Group-based termination only
     if state.active_group_id is not None:
         element_groups = element_to_groups.get(element.ls_id, [])
         if state.active_group_id not in element_groups:
             # Element is not in the active group - terminate
             return True
         return False
 
-    # Fallback: level-based termination (when no group paths)
-    if not is_list_item_element(element):
-        # Non-list-item elements don't terminate lists by themselves
-        # unless they have an explicit lower level
-        if element.level is not None and element.level < state.level_stack[-1]:
-            return True
-        return False
-
-    # For list items, check level conditions
-    if element.level is None:
-        # Unset level terminates the list
-        return True
-
-    if element.level < state.level_stack[-1]:
-        # Lower level terminates inner lists
-        return True
-
     return False
 
 
@@ -171,23 +154,17 @@ def should_start_list(
 
     # Check if element is part of a group
     element_groups = element_to_groups.get(element.ls_id, [])
+    if not element_groups:
+        logger.warning(
+            "list_item %s has no group path — treating as standalone item",
+            element.ls_id,
+        )
+        return False
+
     if element_groups and state.active_group_id is None:
         # Element is in a group but no active group - start new list
         return True
 
-    if not state.level_stack:
-        # No active list and this is a list item - start list
-        return True
-
-    # Check for nested list (higher level)
-    effective_level = (
-        element.level if element.level is not None else state.current_level
-    )
-    if effective_level is not None and state.level_stack:
-        if effective_level > state.level_stack[-1]:
-            # Higher level - start nested list
-            return True
-
     return False