[cDAC] Demonstrate Lock as a cross-source IData<T> type

Per Jan's request on PR dotnet#127310
(dotnet#127310 (comment)),
this commit shows what it takes to add System.Threading.Lock to the
native cdac descriptor. Under the new fallback design, the IData<T>
class stays in one place and gains BOTH sources via a per-field
candidate-name cascade -- not a choose-one-source decision.

Runtime side (3 files, matches the throwaway branch shared with Jan):

  - `src/coreclr/vm/object.h` -- `class LockObject : public Object`
    plus `cdac_data<LockObject>` template exposing the offsets.
  - `src/coreclr/vm/datadescriptor/datadescriptor.inc` -- new
    `CDAC_TYPE_BEGIN(Lock)` block with T_INT32 `OwningThreadId`
    and T_UINT32 `State` / `RecursionCount` fields.
  - `src/coreclr/vm/corelib.h` -- `DEFINE_CLASS_U(Threading, Lock,
    NoClass)` plus `DEFINE_FIELD_U(...)` for the three fields.

Managed side (1 file change vs the throwaway branch's 2):

  - `DataType.cs` -- add `Lock` enum member.
  - `Data/Managed/Lock.cs` -- ONE attribute change. The class gains
    `nameof(DataType.Lock)` alongside `ManagedFullName` and each
    `[Field]` lists both candidate names:

        [CdacType(nameof(DataType.Lock), ManagedFullName = "System.Threading.Lock")]
        internal sealed partial class Lock : IData<Lock>
        {
            [Field("State", "_state")]                   public uint State { get; }
            [Field("OwningThreadId", "_owningThreadId")] public int  OwningThreadId { get; }
            [Field("RecursionCount", "_recursionCount")] public uint RecursionCount { get; }
        }

    The cdac runtime generator emits a `LayoutPairResolver.Resolve`
    call that picks up both sources; each field's read tries
    `"State"` against the native cdac descriptor first, falling
    through to `"_state"` against the managed type metadata when
    needed. No class move / namespace change / caller update.

Contrast with the throwaway branch
(62223d6...b3dfdc8)
which had to delete `Data/Managed/Lock.cs` and add a new
`Data/Lock.cs` with a hand-written ctor and `init` properties,
then update `Contracts/SyncBlock_1.cs` to reference the new
namespace. The new design needs only the runtime-side
`LockObject` plumbing + the single attribute decoration.

Build clean; full cdac test suite still 2206 passing.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Max Charlamb

src/coreclr/vm/corelib.h

@@ -630,6 +630,10 @@ DEFINE_FIELD(MONITOR,               CONDITION_TABLE,        s_conditionTable)
 DEFINE_METHOD(MONITOR,              SYNCHRONIZED_METHOD_ENTER, SynchronizedMethodEnter, SM_Obj_RefBool_RetVoid)
 DEFINE_METHOD(MONITOR,              SYNCHRONIZED_METHOD_EXIT,  SynchronizedMethodExit,  SM_Obj_RefBool_RetVoid)
 
+DEFINE_CLASS_U(Threading,           Lock,                   NoClass)
+DEFINE_FIELD_U(_owningThreadId,     LockObject,             _owningThreadId)
+DEFINE_FIELD_U(_state,              LockObject,             _state)
+DEFINE_FIELD_U(_recursionCount,     LockObject,             _recursionCount)
 DEFINE_CLASS(LOCK,                  Threading,              Lock)
 DEFINE_FIELD(LOCK,                  OWNING_THREAD_ID,       _owningThreadId)
 DEFINE_FIELD(LOCK,                  STATE,                  _state)

src/coreclr/vm/datadescriptor/datadescriptor.inc

@@ -180,6 +180,13 @@ CDAC_TYPE_FIELD(String, T_POINTER, m_FirstChar, cdac_data<StringObject>::m_First
 CDAC_TYPE_FIELD(String, T_UINT32, m_StringLength, cdac_data<StringObject>::m_StringLength)
 CDAC_TYPE_END(String)
 
+CDAC_TYPE_BEGIN(Lock)
+CDAC_TYPE_INDETERMINATE(Lock)
+CDAC_TYPE_FIELD(Lock, T_INT32, OwningThreadId, cdac_data<LockObject>::_owningThreadId)
+CDAC_TYPE_FIELD(Lock, T_UINT32, State, cdac_data<LockObject>::_state)
+CDAC_TYPE_FIELD(Lock, T_UINT32, RecursionCount, cdac_data<LockObject>::_recursionCount)
+CDAC_TYPE_END(Lock)
+
 CDAC_TYPE_BEGIN(ContinuationObject)
 CDAC_TYPE_SIZE(sizeof(ContinuationObject))
 CDAC_TYPE_END(ContinuationObject)

src/coreclr/vm/object.h

@@ -877,6 +877,28 @@ struct cdac_data<StringObject>
     static constexpr size_t m_StringLength = offsetof(StringObject, m_StringLength);
 };
 
+// Native mirror of the managed System.Threading.Lock class layout. This is used
+// only by the cDAC data descriptor to expose the offsets of Lock's relevant
+// instance fields. The field order/types must be kept in sync with the managed
+// declaration in System.Private.CoreLib (System/Threading/Lock.cs).
+class LockObject : public Object
+{
+private:
+    INT32   _owningThreadId;
+    UINT32  _state;
+    UINT32  _recursionCount;
+
+    friend struct ::cdac_data<LockObject>;
+};
+
+template<>
+struct cdac_data<LockObject>
+{
+    static constexpr size_t _owningThreadId = offsetof(LockObject, _owningThreadId);
+    static constexpr size_t _state          = offsetof(LockObject, _state);
+    static constexpr size_t _recursionCount = offsetof(LockObject, _recursionCount);
+};
+
 /*================================GetEmptyString================================
 **Get a reference to the empty string.  If we haven't already gotten one, we
 **query the String class for a pointer to the empty string that we know was

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Managed/Lock.cs

@@ -3,15 +3,15 @@
 
 namespace Microsoft.Diagnostics.DataContractReader.Data.Managed;
 
-[CdacType(ManagedFullName = "System.Threading.Lock")]
+[CdacType(nameof(DataType.Lock), ManagedFullName = "System.Threading.Lock")]
 internal sealed partial class Lock : IData<Lock>
 {
-    [Field("_state")]
+    [Field("State", "_state")]
     public uint State { get; }
 
-    [Field("_owningThreadId")]
+    [Field("OwningThreadId", "_owningThreadId")]
     public int OwningThreadId { get; }
 
-    [Field("_recursionCount")]
+    [Field("RecursionCount", "_recursionCount")]
     public uint RecursionCount { get; }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/DataType.cs

@@ -84,6 +84,7 @@ public enum DataType
     ManagedObjectWrapperLayout,
     ComWrappersVtablePtrs,
     String,
+    Lock,
     MethodDesc,
     MethodDescChunk,
     MethodDescCodeData,