Add --children flag to profile child processes

The ChildProcessMonitor class runs a background thread that polls for
new child processes spawned by the target. When it finds a new Python
process, it launches a separate profiler subprocess with the same
sampling options. Each child profiler writes to its own output file
with the child's PID appended to the filename pattern.

Detection uses a fast path on Linux (checking /proc/{pid}/exe for
"python" in the name) before falling back to the full RemoteUnwinder
probe. Non-Python children are silently skipped. There's a limit of
100 concurrent child profilers to avoid runaway resource usage if the
target forks heavily.

The --children flag is incompatible with --live mode since the curses
interface can't handle multiple profiler outputs simultaneously.

Author: pablogsal

Doc/library/profiling.sampling.rst

@@ -310,6 +310,8 @@ The default configuration works well for most use cases:
      - Wall-clock mode (all samples recorded)
    * - ``--realtime-stats``
      - No live statistics display during profiling
+   * - ``--children``
+     - Profile only the target process (no child process monitoring)
 
 
 Sampling interval and duration
@@ -442,6 +444,79 @@ working correctly and that sufficient samples are being collected. See
 :ref:`sampling-efficiency` for details on interpreting these metrics.
 
 
+Child process profiling
+-----------------------
+
+The :option:`--children` option enables automatic profiling of child processes
+spawned by the target::
+
+   python -m profiling.sampling run --children script.py
+   python -m profiling.sampling attach --children 12345
+
+When enabled, the profiler monitors the target process for child process
+creation. When a new Python child process is detected, a separate profiler
+instance is automatically spawned to profile it. This is useful for
+applications that use :mod:`multiprocessing`, :mod:`subprocess`,
+:mod:`concurrent.futures` with :class:`~concurrent.futures.ProcessPoolExecutor`,
+or other process spawning mechanisms.
+
+.. code-block:: python
+
+   # worker_pool.py
+   from concurrent.futures import ProcessPoolExecutor
+   import math
+
+   def compute_factorial(n):
+       total = 0
+       for i in range(50):
+           total += math.factorial(n)
+       return total
+
+   if __name__ == "__main__":
+       numbers = [5000 + i * 100 for i in range(50)]
+       with ProcessPoolExecutor(max_workers=4) as executor:
+           results = list(executor.map(compute_factorial, numbers))
+       print(f"Computed {len(results)} factorials")
+
+::
+
+   python -m profiling.sampling run --children --flamegraph worker_pool.py
+
+This produces separate flame graphs for the main process and each worker
+process: ``flamegraph.<main_pid>.html``, ``flamegraph.<worker1_pid>.html``,
+and so on.
+
+Each child process receives its own output file. The filename is derived from
+the specified output path (or the default) with the child's process ID
+appended:
+
+- If you specify ``-o profile.html``, children produce ``profile_12345.html``,
+  ``profile_12346.html``, and so on
+- With default output, children produce files like ``flamegraph.12345.html``
+  or directories like ``heatmap_12345``
+- For pstats format (which defaults to stdout), children produce files like
+  ``profile.12345.pstats``
+
+The child profilers inherit most sampling options from the parent (interval,
+duration, thread selection, native frames, GC frames, async-aware mode, and
+output format). All Python descendant processes are profiled recursively,
+including grandchildren and further descendants.
+
+Child process detection works by periodically scanning for new descendants of
+the target process and checking whether each new process is a Python process.
+On Linux, this uses a fast check of the executable name followed by a full
+probe of the process memory if needed. Non-Python child processes (such as
+shell commands or external tools) are ignored.
+
+There is a limit of 100 concurrent child profilers to prevent resource
+exhaustion in programs that spawn many processes. If this limit is reached,
+additional child processes are not profiled and a warning is printed.
+
+The :option:`--children` option is incompatible with :option:`--live` mode
+because live mode uses an interactive terminal interface that cannot
+accommodate multiple concurrent profiler displays.
+
+
 .. _sampling-efficiency:
 
 Sampling efficiency
@@ -1128,6 +1203,11 @@ Sampling options
    Compatible with ``--live``, ``--flamegraph``, ``--heatmap``, and ``--gecko``
    formats only.
 
+.. option:: --children
+
+   Also profile child processes. Each child process gets its own profiler
+   instance and output file. Incompatible with ``--live``.
+
 
 Mode options
 ------------