feat(lena-hands): exp09 graded cross-digit finger weights + honest tear metrics

The exp05 verdict ("weights alone cannot clear the bar on this mesh") was
measured against a hard partition that was itself causing much of the tearing.
exp01-exp05 gave every vert to exactly ONE digit -- 08_finger_weights.py had an
explicit `elif lo in FING: continue  # other digit: hard wall` -- which
guarantees the fused inter-digit bridges tear by the full finger separation,
because a single edge ring absorbs the whole gap.

Replace that with graded blending (WEB_BLEND_R0): a vert's fraction toward its
nearest other digit ramps 0 -> 0.5 as r = d_own/(d_own+d_other) goes 0.35 -> 0.5,
so both sides of the equidistance valley reach 50/50 and the field is continuous
across the boundary. Applied after the smoother (whose hard wall would erode beta
exactly where it must survive) and evaluated in the neighbour digit's own
arc-length frame. WEB_BLEND_SKIP excludes the thumb: its transform is opposition,
not curl, so its frame does not correspond to a finger's.

Measured against an identical baseline (same input, blend the only variable),
real tears (>=1mm rest length) drop 23-60% with NO regression on flat, the pose
that ships: fist_r 1178 -> 530, grip_r 561 -> 222, fist_l 979 -> 633,
grip_l 420 -> 322; total >5x 2487 -> 1307; p99.9 better on every pose;
flat unchanged at 0/1. fin_bones confirms the mechanism rather than just the
count -- the middle<->ring and pinky<->ring families leave the top classes while
the thumb/palm ones are untouched to the edge (182 -> 182, 148 -> 148).

This does NOT make fist/grip shippable: 222-633 real tears still reads as a
destroyed hand in clay renders, and the residual is now ~53% thumb-pad-fused-to
-palm, which is topology and needs mesh surgery or the v02 rebake. Flat and
relaxed are the shippable poses; fist/grip belong to the morph lane for now.

Also here:
- README: the solver's input is v02/..._exp03.glb, NOT exp01. exp01 is pre-hand
  -fit (converter steps 2b/2c); its finger groups sit on the wrist and overlap
  the real finger by 1.6cm, so a solve from it silently zeroes every _02/_03 bone
  -- rigid stick fingers and a torn flat -- while weight sums stay 1.0 and every
  assert passes. Cost three wasted bakes and one false "the solver regressed".
- Seed assert demanded >=100 seeds while the radius loop caps at
  SEED_AXIS_R_MAX, which left pinky (88 seeds at 16mm) can never satisfy; the two
  constants were mutually unsatisfiable. Now >=60, and it is documented as a
  sanity gate rather than a quality bar.
- Detwist poses tested at last: real but marginal (fist_r 38.7x -> 28.7x,
  grip_r 30.0x -> 17.3x, left hand flat). A knob, not a fix.
- edge_stretch_cmp.py / skin_bone_territory.py / handpose_trim_hand_obj.py:
  judge tears by rest length and absolute posed growth, not raw ratio; audit
  whether a bone owns any verts at all (thumb_01 owns ZERO in exp05); and trim
  an arm-sized skin dump to the hand before rendering.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

tools/skin_displacement_check.py

@@ -0,0 +1,97 @@
+"""Pure-python linear-blend skinning check: skin a GLB's verts with its current node TRS
+(what Godot would render) and report max displacement of finger-weighted verts vs the
+original file. usage: skin_check.py posed.glb original.glb"""
+import json, struct, sys, math
+from pathlib import Path
+
+FING = ("thumb", "index", "middle", "ring", "pinky")
+
+def read_glb(path):
+    d = Path(path).read_bytes()
+    length = struct.unpack_from("<I", d, 8)[0]
+    off = 12; g = None; b = None
+    while off < length:
+        clen, ct = struct.unpack_from("<II", d, off); off += 8
+        if ct == 0x4E4F534A: g = json.loads(d[off:off+clen])
+        else: b = d[off:off+clen]
+        off += clen
+    return g, b
+
+def acc(g, b, i):
+    a = g["accessors"][i]; bv = g["bufferViews"][a["bufferView"]]
+    nc = {"SCALAR":1,"VEC2":2,"VEC3":3,"VEC4":4,"MAT4":16}[a["type"]]
+    fmt = {5121:"B",5123:"H",5125:"I",5126:"f"}[a["componentType"]]
+    size = struct.calcsize(fmt)*nc; stride = bv.get("byteStride") or size
+    off = bv.get("byteOffset",0)+a.get("byteOffset",0)
+    return [struct.unpack_from("<%d%s"%(nc,fmt), b, off+i*stride) for i in range(a["count"])], a["componentType"]
+
+def quat_mat(q):
+    x,y,z,w = q
+    return [[1-2*(y*y+z*z),2*(x*y-z*w),2*(x*z+y*w)],
+            [2*(x*y+z*w),1-2*(x*x+z*z),2*(y*z-x*w)],
+            [2*(x*z-y*w),2*(y*z+x*w),1-2*(x*x+y*y)]]
+
+def node_local(nd):
+    t = nd.get("translation",[0,0,0]); r = nd.get("rotation",[0,0,0,1]); s = nd.get("scale",[1,1,1])
+    R = quat_mat(r)
+    M = [[R[i][j]*s[j] for j in range(3)]+[t[i]] for i in range(3)]
+    return M+[[0,0,0,1]]
+
+def matmul(A,B):
+    return [[sum(A[i][k]*B[k][j] for k in range(4)) for j in range(4)] for i in range(4)]
+
+def globals_(g):
+    loc = [node_local(nd) for nd in g["nodes"]]
+    parent = {}
+    for i,nd in enumerate(g["nodes"]):
+        for c in nd.get("children",[]): parent[c] = i
+    memo = {}
+    def gm(i):
+        if i in memo: return memo[i]
+        m = loc[i] if i not in parent else matmul(gm(parent[i]), loc[i])
+        memo[i] = m; return m
+    return [gm(i) for i in range(len(g["nodes"]))]
+
+def skinned_positions(g, b, only_finger=True):
+    names = [nd.get("name","") for nd in g["nodes"]]
+    G = globals_(g)
+    skin = g["skins"][0]
+    joints = skin["joints"]
+    ibm, _ = acc(g, b, skin["inverseBindMatrices"])
+    # glTF matrices are column-major
+    def m16(row):
+        return [[row[c*4+r] for c in range(4)] for r in range(4)]
+    JM = [matmul(G[joints[j]], m16(ibm[j])) for j in range(len(joints))]
+    prim = g["meshes"][0]["primitives"][0]
+    P,_ = acc(g,b,prim["attributes"]["POSITION"])
+    J,_ = acc(g,b,prim["attributes"]["JOINTS_0"])
+    W,wt = acc(g,b,prim["attributes"]["WEIGHTS_0"])
+    wsc = 1.0 if wt==5126 else (1/255 if wt==5121 else 1/65535)
+    out = {}
+    for vi,(p,jr,wr) in enumerate(zip(P,J,W)):
+        if only_finger and not any(any(t in names[joints[j]].lower() for t in FING)
+                                   for j,w in zip(jr,wr) if w>0):
+            continue
+        x=y=z=0.0
+        for j,w in zip(jr,wr):
+            w*=wsc
+            if w<=0: continue
+            M=JM[j]
+            x+=w*(M[0][0]*p[0]+M[0][1]*p[1]+M[0][2]*p[2]+M[0][3])
+            y+=w*(M[1][0]*p[0]+M[1][1]*p[1]+M[1][2]*p[2]+M[1][3])
+            z+=w*(M[2][0]*p[0]+M[2][1]*p[1]+M[2][2]*p[2]+M[2][3])
+        out[vi]=(x,y,z)
+    return out, names, joints
+
+posed_g, posed_b = read_glb(sys.argv[1])
+orig_g, orig_b = read_glb(sys.argv[2])
+a, names, joints = skinned_positions(posed_g, posed_b)
+c, _, _ = skinned_positions(orig_g, orig_b)
+dmax = 0; worst = None
+for vi in a:
+    d = math.dist(a[vi], c[vi])
+    if d > dmax: dmax, worst = d, vi
+print(f"finger-weighted verts: {len(a)}; max displacement posed-vs-original: {dmax*100:.1f} cm (vert {worst})")
+import statistics
+ds = sorted(math.dist(a[vi], c[vi]) for vi in a)
+print(f"median: {ds[len(ds)//2]*100:.2f} cm, p95: {ds[int(len(ds)*0.95)]*100:.2f} cm")