chore(profiling): remove duplicate tests and unneeded test functions (#15403)

## Description

This PR updates tests to be less verbose, and to successfully pass even
if we have different allocation counts between snapshots.

This PR removes:
- 6 deprecated test functions that were using the old `test_snapshot()`
API
- The `test_snapshot()` method itself from `MemoryCollector`
- The `MemorySample` NamedTuple class that was only used by
`test_snapshot()`

These tests are safely redundant because their functionality is now
comprehensively covered by newer tests that use the
`snapshot_and_parse_pprof()` API, which validates against actual pprof
profiles (the format we actually export).

### 1. `test_heap_profiler_sampling_accuracy()` 
**Why it's safe to remove:**
- **Covered by:**
`test_memory_collector_allocation_accuracy_with_tracemalloc()`
- **Coverage:** The replacement test validates sampling accuracy using
tracemalloc as ground truth, testing allocation counts and size accuracy
across multiple sample intervals (256, 512, 1024 bytes)
- **Improvements:** The new test uses the pprof-based approach and
validates both size and count accuracy with statistical assertions

### 2. `test_iter_events()`
**Why it's safe to remove:**
- **Covered by:**
- `test_memory_collector()` - validates allocation capture and sample
structure from pprof profiles
- `test_memory_collector_allocation_accuracy_with_tracemalloc()` -
validates allocation counts and accuracy
- **Coverage:** Both replacement tests verify that allocations are
captured with correct stack traces, thread IDs, and counts from actual
pprof exports

### 3. `test_iter_events_dropped()`
**Why it's safe to remove:**
- **Covered by:**
  - `test_memory_collector()` - validates that allocations are captured
- `test_memory_collector_allocation_accuracy_with_tracemalloc()` -
validates allocation counts meet expected thresholds
- **Coverage:** These tests verify that samples aren't improperly
dropped and allocation counts are accurate

### 4. `test_iter_events_not_started()`
**Why it's safe to remove:**
- **Edge case behavior changed:** The new `snapshot_and_parse_pprof()`
API throws an error if the collector hasn't been started, rather than
returning an empty tuple
- **Not safety-critical:** This tested an edge case that would be caught
immediately in any real usage
- **Better failure mode:** An exception is more obvious than silently
returning empty data

### 5. `test_iter_events_multi_thread()`
**Why it's safe to remove:**
- **Covered by:**
- `test_memory_collector_thread_lifecycle()` - validates allocations
across multiple threads that are created and destroyed dynamically
- `test_memory_collector_buffer_pool_exhaustion()` - validates
concurrent thread allocations with deep stack traces
- **Coverage:** Both tests verify multi-threaded allocation tracking,
with the newer tests being more comprehensive (testing thread lifecycle
and concurrent stress scenarios)

### 6. `test_heap()` and `_test_heap_impl()` helper
**Why it's safe to remove:**
- **Covered by:**
- `test_memory_collector_allocation_tracking_across_snapshots()` -
validates heap (live) vs freed samples with deletions and garbage
collection
- `test_memory_collector_python_interface_with_allocation_tracking()` -
validates multiple snapshot cycles with allocations and frees
- **Coverage:** The replacement tests validate the same behavior
(tracking live vs freed allocations) but using the pprof-based approach
and with more comprehensive scenarios


## Testing

<!-- Describe your testing strategy or note what tests are included -->

## Risks

<!-- Note any risks associated with this change, or "None" if no risks
-->

## Additional Notes

<!-- Any other information that would be helpful for reviewers -->

Author: danielsn

ddtrace/profiling/collector/memalloc.py

@@ -4,16 +4,11 @@
 import threading
 from types import TracebackType
 from typing import Any
-from typing import List
-from typing import NamedTuple
 from typing import Optional
 from typing import Set
-from typing import Tuple
 from typing import Type
 from typing import cast
 
-from ddtrace.profiling.event import DDFrame
-
 
 try:
     from ddtrace.profiling.collector import _memalloc
@@ -30,17 +25,6 @@
 LOG = logging.getLogger(__name__)
 
 
-class MemorySample(NamedTuple):
-    frames: List[DDFrame]
-    size: int
-    count: (  # pyright: ignore[reportIncompatibleMethodOverride] (count is a method of tuple)
-        int  # type: ignore[assignment]
-    )
-    in_use_size: int
-    alloc_size: int
-    thread_id: int
-
-
 class MemoryCollector:
     """Memory allocation collector."""
 
@@ -101,7 +85,7 @@ def _get_thread_id_ignore_set(self) -> Set[int]:
             if getattr(thread, "_ddtrace_profiling_ignore", False) and thread.ident is not None
         }
 
-    def snapshot(self) -> Tuple[MemorySample, ...]:
+    def snapshot(self) -> None:
         thread_id_ignore_set = self._get_thread_id_ignore_set()
 
         try:
@@ -111,7 +95,7 @@ def snapshot(self) -> Tuple[MemorySample, ...]:
         except (RuntimeError, ValueError):
             # DEV: This can happen if either _memalloc has not been started or has been stopped.
             LOG.debug("Unable to collect heap events from process %d", os.getpid(), exc_info=True)
-            return tuple()
+            return
 
         for event in events:
             (frames, thread_id), in_use_size, alloc_size, count = event
@@ -138,31 +122,6 @@ def snapshot(self) -> Tuple[MemorySample, ...]:
                     #      re-initialization.
                     LOG.debug("Invalid state detected in memalloc module, suppressing profile")
 
-        return tuple()
-
-    def test_snapshot(self) -> Tuple[MemorySample, ...]:
-        thread_id_ignore_set = self._get_thread_id_ignore_set()
-
-        try:
-            if _memalloc is None:
-                raise ValueError("Memalloc is not initialized")
-            events = _memalloc.heap()
-        except (RuntimeError, ValueError):
-            # DEV: This can happen if either _memalloc has not been started or has been stopped.
-            LOG.debug("Unable to collect heap events from process %d", os.getpid(), exc_info=True)
-            return tuple()
-
-        samples: List[MemorySample] = []
-        for event in events:
-            (frames, thread_id), in_use_size, alloc_size, count = event
-
-            if not self.ignore_profiler or thread_id not in thread_id_ignore_set:
-                size = in_use_size if in_use_size > 0 else alloc_size
-
-                samples.append(MemorySample(frames, size, count, in_use_size, alloc_size, thread_id))
-
-        return tuple(samples)
-
     def snapshot_and_parse_pprof(self, output_filename: str) -> Any:
         """Export samples to profile, upload, and parse the pprof profile.
 
@@ -193,6 +152,3 @@ def snapshot_and_parse_pprof(self, output_filename: str) -> Any:
             )
 
         return pprof_utils.parse_newest_profile(output_filename)
-
-    def collect(self) -> Tuple[MemorySample, ...]:
-        return tuple()