fix(emulator): stop repeating network access warnings for a URL already reported

[gauranshahuja]

Description

Fixes #4939.

The Functions emulator repeats External network resource requested! (and the Google API requested!
variant) for the same URL over and over, which buries everything else in a project that talks to external
services. Two people asked for a way to turn it off; the only workaround in the thread is hand-editing
emulatorLogger.js inside node_modules.

The warning is not actually per-request. initializeNetworkFiltering() in functionsEmulatorRuntime.ts
already dedupes by href:

const history: { [href: string]: boolean } = {};
...
if (href && !history[href] && !isLocalHost(href)) {
  history[href] = true;

but history is function-scoped and initializeNetworkFiltering() runs once per runtime process. The
worker pool spawns a fresh runtime, the cache goes with the old one, and the same URL is announced again.

So the dedup needs to live in the parent, which already has the mechanism: RuntimeWorker calls
handleRuntimeLog in the emulator process, and EmulatorLogger.warnOnceCache is static, so it spans every
runtime for the whole session. This changes the two network-access cases in handleSystemLog from WARN
to WARN_ONCE. WARN_ONCE keys on the rendered text, which contains the href, so every distinct URL is
still reported - once per emulator session instead of once per runtime. Nothing is hidden, only repeated
lines are dropped. It also matches what this file already does for functions-config-missing-value, the
other advisory that can repeat.

Worth noting there is currently no way to silence just these: --log-verbosity QUIET does not suppress
warnings at all (WARN and QUIET are both verbosity 2, and shouldSupress is >), and SILENT takes
ERROR with it.

The issue asks for "some parameter when starting emulators that would disable the output of certain types
of notifications". I have deliberately not added a firebase.json key or a flag - that is a design call
that belongs to you, and this fix removes the pain without one. If you would rather have an explicit
opt-out as well, say the shape you want and I will add it here.

Scenarios Tested

src/emulator/emulatorLogger.spec.ts is new - this file had no unit test before. It drives the real path
(handleRuntimeLog with a SYSTEM log, which is what RuntimeWorker calls):

• the same external URL reported from three separate logger instances, standing in for three runtimes from
  the worker pool, warns once
• two distinct URLs with a repeat in between warn twice, in order - the check that nothing is lost
• the same for the googleapis-network-access branch
• one warning of each kind still produces two warnings
• non-default-admin-app-used three times still warns three times, so other warnings are untouched

Also run locally: npx tsc --project tsconfig.compile.json --noEmit clean; eslint on the touched files
reports no new warnings (the untouched file produces the same count); prettier clean; the
src/emulator/*.spec.ts suite.

Sample Commands

No new commands or flags. Before, in a project that calls the same API from several runtimes:

⚠  External network resource requested!
   - URL: "https://api.example.com/v1/thing"
 - Be careful, this may be a production service.
⚠  External network resource requested!
   - URL: "https://api.example.com/v1/thing"
 - Be careful, this may be a production service.
... repeated for every new runtime

After: that block appears once per URL per emulator session. A second, different URL still gets its own
warning.

[gemini-code-assist]

Code Review

This pull request resolves an issue where the Functions emulator repeatedly logs warnings for the same external network or Google API requests across different runtime processes. By changing the log level from 'WARN' to 'WARN_ONCE' for these events, the emulator now deduplicates warnings by URL over the course of an emulator session. Unit tests have been added to verify this behavior, and the changelog has been updated. I have no feedback to provide as the changes are well-implemented and include appropriate test coverage.