[checks_codegen] Generate full field types with imports - #2781

Generated getters referenced the field type by the name of its element
only, so type arguments were never imported and function typed fields
were skipped entirely. Imports were also searched only among the test
library's direct imports, so types reached by the checked class through
a re-export fell back to src/ libraries or uncompilable dart:_* SDK
libraries.

First walk the checked classes and their field types to collect every
referenced interface element and resolve an import URI for each, then
emit type references synchronously from the analyzer DartType:

• Interface types import the library for each element, including within
  type arguments.
• Function types, including generic function types with bounds, and
  record types are emitted structurally.
• dynamic, void, and Never are emitted directly.
• Type parameters of the checked class are replaced with their bounds by
  reading getter types from the class instantiated to bounds. The
  extension is on the raw type, so this matches the static type of
  v.field.
• Unresolvable types (InvalidType) fail naming the class and field,
  with a source span on the field and a hint to check for a missing
  build dependency.

Function typed fields now get getters. Fields without a getter, such as
those introduced by a lone setter, are skipped.

Import resolution searches for a library exporting each non-public-SDK
element in order:

1. The imports of the test library.
2. The imports of every library declaring a referenced element.
3. For elements declared in dart:_* libraries, public SDK libraries:
   first those reachable through imports and exports from the test and
   declaring libraries (so e.g. HttpStatus prefers dart:io over
   dart:html in a VM program), then any remaining public SDK
   libraries, each sorted by URI.

The first two groups prefer libraries outside src/. If no library
exports an element, fall back to its declaring library (which may be in
src/), or fail if that is a dart:_* library.

Note on conditional directives: build_runner resolves code with empty
DeclaredVariables, so conditional import/export directives always
follow their default URI during codegen, never an if (dart.library.*)
branch. When a barrel conditionally exports src/ implementations,
codegen now imports the barrel rather than the default src/ stub, so
test compilation evaluates the condition for the target platform. When a
declaring library uses a conditional import directly, codegen still
sees only the default branch: a stub default yields the stub's types as
before, while an IO default exposing types like HttpHeaders or
HttpStatus now emits dart:io (compiling on VM, instead of emitting
dart:_http/dart:_internal which failed everywhere) but still will
not compile for web unless the test library imports a compatible
exporter.