fix(pt_expt): compiled training runs the graph lower (eager==compiled); drop force_legacy_descriptor

Retarget _CompiledModel to compile forward_common_lower_graph for graph-eligible
descriptors (dpa1 attn_layer==0), gated by the same mixed_types()+uses_graph_lower()
predicate the eager default-flip uses; se_e2_a/dpa2/dpa3 keep compiling the dense
forward_lower. _trace_and_compile_graph builds a synthetic NeighborGraph with
prime-distinct nf/N/E axes (no make_fx duck-shape merge) and edge_vec as the
autograd leaf; _forward_graph builds the carry-all graph eagerly and unravels flat
(N,*) node outputs to (nf,nloc,*). cpp.simdlen=0 for the graph compile avoids an
inductor CPU scatter-vectorizer crash on the per-frame virial atomic_add.

Also fixes an eager autograd bug in dpa1 call_graph: xp.asarray(type_embedding,
device=dev) DETACHES under torch, so the type-embedding weights never trained in
the graph path (grad None despite a real finite-diff dependency). make_fx traced
through it, so compiled != eager and the optimizer diverged after step 0. Use
type_embedding directly (mirrors the dense path); the tebd net now trains and
eager==compiled to 1e-10 across the varying-natoms trajectory.

Drops the force_legacy_descriptor workaround + uses_graph_lower monkeypatch.

Author: Han Wang

deepmd/dpmodel/descriptor/dpa1.py

@@ -757,9 +757,13 @@ def call_graph(
         )
         # FLAT node axis (N, ...): no (nf, nloc) reshape -- ragged-native, spec.
         if self.concat_output_tebd:
-            tebd = xp.asarray(type_embedding, device=dev)
+            # Use type_embedding directly (mirrors the dense path's
+            # ``xp.take(type_embedding, ...)``): ``xp.asarray(..., device=dev)``
+            # DETACHES under torch, silently severing the type-embedding weight
+            # gradient so the tebd net never trains; type_embedding already lives
+            # on the model device, so the device cast was redundant anyway.
             atype_local = xp.asarray(atype, device=dev)
-            atype_embd = xp.take(tebd, atype_local, axis=0)  # (N, tebd_dim)
+            atype_embd = xp.take(type_embedding, atype_local, axis=0)  # (N, tebd_dim)
             grrg = xp.concat([grrg, atype_embd], axis=-1)
         return grrg, rot_mat
 
@@ -1523,7 +1527,10 @@ def call_graph(
         ss = rr[:, 0:1]  # (E, 1)
         # neighbor / center type embeddings (concat mode); ghost type == owner type
         # so gathering by the LOCAL owner (src) reproduces the dense neighbor tebd.
-        tebd = xp.asarray(type_embedding, device=dev)
+        # NB: do NOT wrap in ``xp.asarray(..., device=dev)`` -- that DETACHES under
+        # torch and severs the type-embedding weight gradient (the tebd net would
+        # never train); type_embedding already lives on the model device.
+        tebd = type_embedding
         atype_embd_nlist = xp.take(tebd, nei_type, axis=0)  # (E, tebd_dim)
         if not self.type_one_side:
             atype_embd_nnei = xp.take(tebd, center_type, axis=0)  # (E, tebd_dim)