Cache lock-order edges per thread so DeadlockCheck() can skip deadlock_graph_mu.

In debug builds with deadlock detection enabled, a thread that acquires a Mutex
while it holds another takes the global deadlock_graph_mu spinlock, to insert
the lock-order edges from its held locks into deadlock_graph. Most of these
acquisitions find every edge already in the graph, but with many threads they
still contend on deadlock_graph_mu.

Give each thread a 512-entry direct-mapped cache of the edges that it has found
or inserted in deadlock_graph. If every edge from a held lock to the new lock
has a valid cache entry, DeadlockCheck() takes the held locks' GraphIds from
the cache and returns without deadlock_graph_mu. A hit skips only work that
would leave deadlock_graph unchanged:

- Edges leave deadlock_graph only when one of their nodes is removed, so an
  entry is valid while both of its nodes are still in the graph. The new
  GraphCycles::IsCurrent() checks this by comparing node versions, without
  deadlock_graph_mu. RemoveNode() bumps the version, so an entry for a
  destroyed or forgotten Mutex misses, even if a new Mutex reuses its address.
  The check is exact per node: removing a node does not invalidate entries for
  other nodes.
- DeadlockCheck() replaces a lock's stored stack trace when the thread holds
  more locks than when that trace was taken. So that a hit never skips this,
  each entry records the lock depth at which it was cached, and serves only
  acquisitions at that depth or lower.

Cost: 28 KiB per thread, zero-initialized on the thread's first nested lock
acquisition, only in debug builds with deadlock detection enabled.
PiperOrigin-RevId: 997581889