[dynamic Instrumentation] DEBUG-2336 Add Concurrent Adaptive Cache (#6093)

## Summary of changes
This PR introduces a thread-safe, adaptive caching system that
automatically adjusts to system resources and usage patterns. The cache
implements both LRU (Least Recently Used) and LFU (Least Frequently
Used) eviction policies and features dynamic cleanup intervals based on
expiration patterns.

### Key Features

- Sliding Expiration: Items expire after a configurable period of
inactivity
- Adaptive Cleanup: Cleanup interval adjusts between 5-60 minutes based
on expiration patterns
- Resource Awareness: Automatically reduces capacity in low-resource
environments
- Thread Safety: All operations are protected by reader-writer locks for
concurrent access


## Implementation

#### Main cache implementation with:
- Automatic capacity adjustment (2048 default, 512 for low-resource
environments)
- Dynamic cleanup interval (300s-3600s) that adjusts based on expiration
patterns
- Thread-safe operations using reader-writer locks
- Hit rate tracking and monitoring


#### Eviction Policies:
- LRU: Uses LinkedList + Dictionary for O(1) access and eviction
- LFU: Implements frequency tracking with SortedDictionary for efficient
eviction


#### Environment Detection:
- Serverless environment detection (AWS Lambda, Azure Functions)
- Memory availability checking (Windows and Unix systems)
- Automatic capacity adjustment based on system resources


## Testing
- Basic operations (Add, TryGet, GetOrAdd)
- Eviction policy behavior (LRU and LFU)
- Thread safety with parallel operations
- Sliding expiration functionality
- Cleanup interval adaptation
- Resource-based capacity adjustment
- Hit rate calculation
- Proper disposal of resources

Author: dudikeleti

tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml

@@ -589,6 +589,7 @@
       <type fullname="System.Func`6" />
       <type fullname="System.Func`7" />
       <type fullname="System.GC" />
+      <type fullname="System.GCMemoryInfo" />
       <type fullname="System.Globalization.CultureInfo" />
       <type fullname="System.Globalization.DateTimeStyles" />
       <type fullname="System.Globalization.NumberFormatInfo" />

tracer/src/Datadog.Trace/Debugger/Caching/CacheItem.cs

@@ -0,0 +1,51 @@
+// <copyright file="CacheItem.cs" company="Datadog">
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
+// </copyright>
+
+#nullable enable
+
+using System;
+using System.Threading;
+
+namespace Datadog.Trace.Debugger.Caching;
+
+internal class CacheItem<TValue>
+{
+    private readonly DateTime _created;
+    private long _lastAccessed;
+    private long _accessCount;
+
+    public CacheItem(TValue? value, TimeSpan? slidingExpiration)
+    {
+        if (slidingExpiration.HasValue && slidingExpiration.Value <= TimeSpan.Zero)
+        {
+            throw new ArgumentException("Sliding expiration must be positive", nameof(slidingExpiration));
+        }
+
+        Value = value;
+        _created = DateTime.UtcNow;
+        LastAccessed = _created;
+        SlidingExpiration = slidingExpiration;
+    }
+
+    public DateTimeOffset Created => _created;
+
+    public TimeSpan? SlidingExpiration { get; set; }
+
+    public TValue? Value { get; set; }
+
+    internal DateTimeOffset LastAccessed
+    {
+        get => DateTime.FromBinary(Interlocked.Read(ref _lastAccessed));
+        set => Interlocked.Exchange(ref _lastAccessed, value.UtcDateTime.ToBinary());
+    }
+
+    internal long AccessCount => Interlocked.Read(ref _accessCount);
+
+    internal void UpdateAccess(DateTime now)
+    {
+        LastAccessed = now;
+        Interlocked.Increment(ref _accessCount);
+    }
+}