ROI tree: walk innervates + drop depth cap; fix painted_index label fallback

v1.13.2's get_template_roi_tree walked the painted-leaf paths through
[:SUBCLASSOF|part_of*0..20] only. On the adult VNS template, 16 of the
22 painted Individuals are nerves (FBbt_00004019 / _00004055-63 /
_00004094-99 / _00004105-08 / _00007657) whose part_of chain goes to
adult peripheral nervous system, NOT to the central VNC root. They
connect to the VNC neuromeres via the `innervates` relation instead.
The legacy v2 Cypher had the same edge set and the same gap; with v2's
visual tree typically loading JFRC2 by default it was easy to miss.

Changes:

- Cypher walk: extend to [:SUBCLASSOF|part_of|innervates*0..]. Adult VNS
  Court2018 now renders 26 nodes (was 8) with all 22 painted classes
  surfaced; JRC2018UnisexVNC gains its nerves; Hemibrain + Ito2014 gain
  their antennal / labellar / abdominal nerves. Templates that have no
  painted nerves (JFRC2, JRC2018Unisex, T1 Leg, larval CNS, Adult Head)
  are unchanged.
- Depth cap *0..20 dropped to *0.. on Robbie's call: the cache absorbs
  the cold-cache delay (all ten test templates still complete cold in
  <2.4s on pdb), and the cap risked silently truncating future deep
  ontology paths.
- painted_domain_index class_label fallback: when a painted class
  isn't reached by the tree walk (e.g. orphaned by relations we don't
  traverse), use the class_label captured in painted_rows. v1.13.2 left
  these as null and any tooltip/debug surface keying off the reverse
  lookup would have rendered "None".

Cache bucket renamed template_roi_tree -> template_roi_tree_v2 so the
v1.13.2 cache entries (built with the narrower rel-set) don't shadow
the new walk. Surgical invalidation - no minor bump needed, other
queries' caches are untouched.

Verified against pdb for all 10 production templates:

  template               nodes  edges  painted    rel mix
  JRC2018Unisex             77     92       46    part_of=89, SUBCLASSOF=3
  JFRC2 brain               70     85       58    part_of=82, SUBCLASSOF=3
  JRC_FlyEM_Hemibrain       97    122       97    part_of=97, SUBCLASSOF=16, innervates=9
  Ito2014 brain            110    168       75    part_of=118, SUBCLASSOF=10, innervates=40
  JRC2018UnisexVNC          30     46       21    part_of=21, SUBCLASSOF=16, innervates=9
  adult VNS Court2018       26     28       22    innervates=14, SUBCLASSOF=10, part_of=4
  L1 larval CNS              0      0        0    (no painted data)
  L3 CNS Wood2018          140    328      255    part_of=199, SUBCLASSOF=129
  Adult T1 Leg               3      2        4    part_of=2
  Adult Head McKellar       30     46       18    SUBCLASSOF=29, part_of=17

All cold-cache runs sub-2.4s. No __version__ bump.

Author: Robbie1977

src/vfbquery/cached_functions.py

@@ -325,7 +325,7 @@ def get_painted_domains_cached(template_short_form: str, return_dataframe=True,
     """
     return _original_get_painted_domains(template_short_form=template_short_form, return_dataframe=return_dataframe, limit=limit)
 
-@with_solr_cache('template_roi_tree')
+@with_solr_cache('template_roi_tree_v2')
 def get_template_roi_tree_cached(template_short_form: str, return_dataframe: bool = False, force_refresh: bool = False):
     """
     Enhanced get_template_roi_tree with SOLR caching.

src/vfbquery/vfb_queries.py

@@ -4883,18 +4883,27 @@ def get_painted_domains(template_short_form: str, return_dataframe=True, limit:
 _VFB_SHORT_FORM_RE = re.compile(r"^[A-Za-z0-9_]+$")
 
 
-@with_solr_cache('template_roi_tree')
+@with_solr_cache('template_roi_tree_v2')
 def get_template_roi_tree(template_short_form: str, return_dataframe=False):
     """Build a hierarchical ROI tree for a template.
 
     Anchors on the template's INSTANCEOF root Class (so this works for
     every template regardless of anatomical character — adult brain
     variants, adult VNC, larval CNS, the Adult T1 Leg with muscles +
-    neuropils, Adult Head). Walks down through ``part_of`` and
-    ``SUBCLASSOF`` to every Class that has a painted-domain Individual on
-    this template, materialising the nodes and edges required to render
-    the tree. FBbt's DAG character is preserved (multi-parent classes
-    appear under each parent), matching the legacy VFBTree behaviour.
+    neuropils, Adult Head). Walks down through ``part_of``, ``SUBCLASSOF``
+    and ``innervates`` to every Class that has a painted-domain Individual
+    on this template, materialising the nodes and edges required to
+    render the tree. ``innervates`` is what connects e.g. the adult VNC
+    nerves (which are part_of the peripheral nervous system, NOT the
+    central VNC) to the neuromeres they innervate, so without it the
+    legacy walk dropped 16 of the 22 painted VNS nerves from the tree.
+
+    Cache bucket ``template_roi_tree_v2`` (was ``template_roi_tree``)
+    forces a clean re-populate so v1.13.2 entries with the narrower
+    rel-set don't shadow the new walk.
+
+    FBbt's DAG character is preserved (multi-parent classes appear under
+    each parent), matching the legacy VFBTree behaviour.
 
     Returned shape (`return_dataframe` is accepted for symmetry; this
     query is hierarchical and always returns the dict shape):
@@ -4950,7 +4959,7 @@ def get_template_roi_tree(template_short_form: str, return_dataframe=False):
         f"WITH t, root, "
         f"[r IN painted_rows WHERE r.class_id IS NOT NULL] AS painted_rows "
         f"WITH t, root, painted_rows, [r IN painted_rows | r.class_id] AS leaf_ids "
-        f"OPTIONAL MATCH path = (root)<-[:SUBCLASSOF|part_of*0..20]-(leaf:Class) "
+        f"OPTIONAL MATCH path = (root)<-[:SUBCLASSOF|part_of|innervates*0..]-(leaf:Class) "
         f"WHERE leaf.short_form IN leaf_ids "
         f"WITH t, root, painted_rows, "
         f"collect(distinct [n IN nodes(path) | "
@@ -5054,10 +5063,27 @@ def _build(node_id, ancestors, parent_label):
         f"region to toggle its overlay on the 3D viewer."
     )
 
+    # painted_class label fallback: any class found by the painted-collection
+    # half of the Cypher carries its own label, so use that when the
+    # tree-walk half didn't reach the class (this happens when the only
+    # path from root to the leaf relies on a relation we don't traverse,
+    # so the class is in painted_by_class but not in nodes_by_id).
+    class_label_by_id = {
+        cid: (plist[0].get('class_label') if plist else None)
+        for cid, plist in painted_by_class.items()
+    }
+    # painted_by_class doesn't store the class_label directly (we project
+    # only individual_id / individual_label into the per-class list), so
+    # rebuild from painted_rows where it does live.
+    for r in painted_rows:
+        cid = r.get('class_id')
+        if cid and not class_label_by_id.get(cid):
+            class_label_by_id[cid] = r.get('class_label')
+
     painted_index = {
         p['individual_id']: {
             'class_id':    cid,
-            'class_label': nodes_by_id.get(cid),
+            'class_label': nodes_by_id.get(cid) or class_label_by_id.get(cid),
         }
         for cid, plist in painted_by_class.items()
         for p in plist