… engine-internal shaders

Flutter GPU user shaders, FragmentProgram (RuntimeEffect) shaders, and
Impeller's own entity-contents shaders all register into the same
per-Context impeller::ShaderLibrary, keyed only on (entrypoint name,
stage). Because impellerc derives entrypoint names from source file
stems with no scope prefix, a user-supplied shader whose .frag stem
matches an Impeller-internal one would either shadow it on lookup or,
in the FragmentProgram case (which intentionally evicts the previous
function on dirty re-load to support hot reload), actively unregister
the engine's pipeline function.

Add a small ShaderKey::MakeUserScopedName helper that prefixes user
shader entrypoints with "<scope>:<library_id>:" before they go into the
shared registry. Engine-internal entrypoints stay unprefixed and are
not spoofable, since impellerc-generated names are valid identifiers
and cannot contain ':'. The library_id is anchored to the asset path
the shader was loaded from (FragmentProgram via SetLibraryId on
RuntimeStage; Flutter GPU via the asset name plumbed through
ShaderLibrary::MakeFromFlatbuffer), so hot reload of the same asset
continues to evict and replace the same registry slot, and shaders
loaded from different packages or different asset bundles never
collide.

Fixes flutter#175464.

…k id, tighten append

- Cache the scoped fragment registry name on RuntimeEffectContents at
  SetRuntimeStage time so that the per-frame Render path no longer
  re-allocates and re-concatenates it on every call.
- Move the fallback library-id helper (used when no asset path is
  available) into ShaderKey::MakeFallbackLibraryId so the runtime stage
  decode path and the Flutter GPU bundle path share one source of truth
  and one process-wide counter, and use std::to_string instead of
  std::ostringstream.
- Tighten ShaderKey::MakeUserScopedName to use std::string::append with
  std::string_view directly.

impeller/renderer (where ShaderKey lives) already depends on
impeller/runtime_stage, so runtime_stage.cc cannot pull in
ShaderKey::MakeFallbackLibraryId without creating a cycle. Restore a
TU-local helper in runtime_stage.cc and document why; flutter::gpu
continues to use the shared ShaderKey helper since lib/gpu already
depends on impeller/renderer. Both helpers use std::to_string per the
earlier review feedback.

* `ShaderKey::MakeUserScopedName` and `ShaderKey::MakeFallbackLibraryId`
  now use `absl::StrCat` instead of the manual `reserve` / `append` /
  `push_back` pattern. Improves readability and matches the prevailing
  style used elsewhere in Impeller.
* Adds `ShaderKeyTest.MakeUserScopedNameHandlesLongInputs` covering a
  4096-byte `library_id` and a 2048-byte `entrypoint`. The scoped name
  is only used as a `std::string` key in the per-process shader library
  registry, so there is no fixed length limit; this pins that
  expectation against future regressions.
* Adds the `absl::strings` dependency to `impeller/renderer/BUILD.gn`
  for `absl::StrCat`.

…tPrograms

Adds Dart-level integration tests that pin the user-visible behavior the
shader namespacing change is supposed to deliver: two distinct user
shader sources that share an embedded entrypoint name can be loaded and
used in the same process without colliding in the shared shader library.

* `testing/dart/gpu_test.dart`: new `Two shader bundles with the same
  entrypoint names do not collide` test that loads `test.shaderbundle`
  and a new `test_alt.shaderbundle` (both exporting `UnlitFragment` and
  `UnlitVertex`), constructs a `RenderPipeline` from each, and renders
  with both. Pre-namespacing this would have torn one of the two
  pipelines down at registration time.

* `lib/ui/fixtures/shaders/BUILD.gn`: new `flutter_gpu_shaders_alt`
  impellerc target that produces `test_alt.shaderbundle` with the same
  `UnlitFragment` / `UnlitVertex` entrypoints as the existing bundle.

* `testing/dart/fragment_shader_test.dart`: new `FragmentPrograms from
  different asset paths do not collide` test that loads
  `no_uniforms.frag.iplr` and a byte-identical alias
  `no_uniforms_alt.frag.iplr`, gets a `FragmentShader` from each, and
  paints a Picture with both. `no_uniforms.frag` was chosen so the test
  does not need to thread sampler or uniform setup through the
  FragmentShader to validate it.

* `lib/ui/fixtures/shaders/general_shaders/BUILD.gn`: new `no_uniforms_alt`
  copy action that publishes `no_uniforms.frag.iplr` under a second
  asset name so FragmentProgram tracks the two loads under distinct
  library ids.

Verified locally on both `flutter_tester` (Metal) and
`flutter_tester_opengles` (SwANGLE). The unrelated
`impellerc produces reasonable JSON encoded IPLR files` failure in
`fragment_shader_test.dart` is pre-existing on master.

…sion test

CI analyzer flagged `omit_obvious_local_variable_types` on four locals
in the new `FragmentPrograms from different asset paths do not collide`
test where the right-hand side is a constructor call (`Paint()`,
`PictureRecorder()`, `Canvas(...)`) or a typed list literal (loop
variable). Drop the annotations so the lint passes.

The prior fix for `omit_obvious_local_variable_types` overshot by also
dropping the type annotation on `final picture = recorder.endRecording()`
at fragment_shader_test.dart:88. `PictureRecorder.endRecording()` is a
method call, not a constructor, so the analyzer considers the type
non-obvious and the `specify_nonobvious_local_variable_types` lint fired
on the next CI run. Restore `final Picture picture = ...` to keep the
annotation on the function-call return while leaving the constructor
locals (`Paint paint = Paint()`, `PictureRecorder recorder = ...`,
`Canvas canvas = Canvas(...)`) without explicit types.

Verified locally: `engine/src/flutter/ci/analyze.sh` reports
"No issues found!".