Two changes that together reduce Extractor#extract_all peak memory from
74 MB to 61 MB on a 2500-user-class workload (-17.6%, measured via
benchmarks/symbol_database_extraction.rb from #5798), with per-iteration
wall time within noise.

Streaming yield (extractor.rb, component.rb)

extract_all now accepts an optional block. When a block is given, FILE
scopes are yielded one at a time and the per-file tree node is shifted
out of the in-progress hash as it is yielded, so the caller can free
each scope after consuming it without retaining the full Array<Scope>.
The entries hash from Pass 1 is also dropped before Pass 3 begins, so
its UnboundMethod references become eligible for collection at the
next GC instead of staying alive for the whole Pass 3 conversion.

Without a block, extract_all still returns the full Array<Scope> as
before \u2014 preserves the test/benchmark API.

Component.extract_and_upload uses the block form and accumulates the
extracted_count + targetable_count inline rather than walking the full
array after extraction. count_targetable_methods was split so the
per-scope helper count_targetable_methods_in_scope is reusable in the
streaming loop (the wrapper that takes the full Array is kept).

Skip redundant visibility scan (extractor.rb)

Module#instance_methods(false) already returns both public and
protected methods. group_methods_by_file was iterating
instance_methods + protected_instance_methods + private_instance_methods
with a uniq! to drop the duplicated protected entries. Iterating only
instance_methods + private_instance_methods covers all three
visibilities without the redundant scan or the merged-array
allocation.

Refactor extract_all from a 3-pass collect/build/convert that retained
every module's UnboundMethods until the final conversion, into a 2-pass
index/build flow that holds at most one file's working set at a time.

Pass 1 (new build_per_file_index):
- Walks ObjectSpace.each_object(Module) once.
- For each user-code module, records (file_path, module_ref, method_name_symbols)
  per file the module contributes to.
- Stores Symbol method names plus Module references only. No UnboundMethod
  objects retained between passes. The UnboundMethods allocated to read
  source_location become garbage as the inner loop ends.

Pass 2 (new build_file_scope):
- For each file in the index, resolves UnboundMethods just-in-time for the
  modules that contribute to it and builds the FILE scope with full nested
  MODULE/CLASS hierarchy (same output as the old extract_all).
- When extract_all is called with a block, the index is drained
  destructively (index.shift), so each per-file entry becomes collectable
  as soon as its FILE scope is yielded and consumed.

Output shape unchanged. All existing extract_all specs pass (the one
that stubbed collect_extractable_modules was updated to stub
build_per_file_index instead).

Measured memory effect (taskset -c 0,1, no_turbo=1, vs PR baseline +
the earlier A+D commit):

  Classes  no-block(KB)   block-streaming(KB)
  1500     20,308         ~6,000   (-85% vs original A baseline)
  2500     41,592         ~10,700  (-85%)
  3500     50,032         ~12,900  (-85%)
  5000     71,060         ~16,400  (-83%)
  8000    107,996         ~23,300  (-85%)

The block-form (used by Component) now scales at ~2.3 MB per 1000
additional user classes, down from ~14 MB previously. The remaining
growth is mostly the Ruby runtime's own per-class footprint (method
tables, constant slots) that the extractor walks but does not allocate
\u2014 it is also visible in baseline RSS growth across the same sizes.

The legacy collect_extractable_modules / build_file_trees /
convert_trees_to_scopes / group_methods_by_file methods are kept for
tests that exercise the old shape; extract_all no longer uses them.

Apply review fixes to the per-file streaming index work:

- Fix shadowing-outer-local-variable warning at extract_all (Ruby 2.5/2.6)
  by switching the block-form drain to while(pair = shift) + pair[0]/pair[1]
  indexing so the else-branch's |path, file_entries| block params have no
  outer-scope binding to shadow.

- Update RBS signatures: extract_all now accepts an optional block and
  returns nil in block form; add declarations for build_per_file_index,
  collect_method_names_by_file, build_file_scope, convert_tree_to_scope,
  count_targetable_methods_in_scope; remove the now-dead
  count_targetable_methods RBS entry.

- Remove count_targetable_methods (dead after extract_and_upload moved to
  inline per-scope accumulation).

- Add trailing commas in build_file_scope's root hash and
  convert_tree_to_scope's Scope.new call.

- Rewrite the extract_all header comment to match the new two-pass design
  (build_per_file_index → build_file_scope) instead of the old three-pass
  one.

- Update convert_tree_to_scope's @param doc to note both callers
  (build_file_trees and build_file_scope).

- Add block-form tests in extractor_spec.rb covering: yield-per-FILE,
  return-nil contract, scope equivalence with the non-block form, and
  top-level rescue behavior under block form.

Verified locally:
- bundle exec steep check: no errors
- bundle exec rspec spec/datadog/symbol_database/{extractor,component,integration}_spec.rb:
  181 examples, 0 failures
- ruby -W2 require of extractor.rb: no warnings

The streaming index drops UnboundMethod objects between passes:
build_per_file_index (Pass 1) records (mod, method_name, file_path) and
build_file_scope (Pass 2) re-resolves the UnboundMethod via
mod.instance_method(name). If the method is redefined in another file
between the two passes (Rails class reload while extract_all is iterating),
Pass 2 gets an UnboundMethod whose source_location is the new file but
attributes it to the file_path recorded in Pass 1. The legacy path retained
the original UnboundMethod and so couldn't mix files this way.

Address review comment by adding a source_location recheck in
build_file_scope. After resolving, compare method.source_location[0] to the
recorded file_path; drop the entry if they no longer match. When every
recorded method for a module has moved out of file_path, drop the module
entry entirely so the FILE scope doesn't carry an empty CLASS/MODULE node
at a location the module no longer lives in. The hot-load TracePoint
enqueues the redefined class and the next debounce window extracts it
under the new file_path.

Test added: build_file_scope receives a (mod, name) tuple whose method
source_location no longer matches the file_path; the FILE scope collapses
to nil rather than emitting a CLASS node at the stale location.

Verified locally:
- bundle exec rspec spec/datadog/symbol_database/: 359 examples, 0 failures
- bundle exec steep check lib/datadog/symbol_database/extractor.rb: clean

Co-Authored-By: Claude <[email protected]>

The Pass 1 \u2192 Pass 2 stale-method recheck added in c0771a8 uses
`next if method_names.any? && method_infos.empty?` to drop module
entries whose every recorded method has moved out of file_path. The
`method_names.any?` qualifier is what keeps namespace-only modules
(empty method-name list via the find_source_file fallback) from being
incorrectly dropped.

Add a regression test exercising the namespace-only path through
build_file_scope. Without the `method_names.any?` qualifier this test
would fail because an empty method_names list also produces an empty
method_infos list, and the guard would skip the module entry.

Verified:
- bundle exec rspec spec/datadog/symbol_database/{component,extractor,integration}_spec.rb: 186 examples, 0 failures
- bundle exec rake standard typecheck: clean