allow proxy config during ng build when using `outputMode: server`

### Command

build

### Description

I am facing a separate, but similar issue to #29005
@alan-agius4, in my case, the 30-sec timeout occurs because I am making api calls.

My setup is pretty standard:
- 2 angular 'client' apps (ssr with fastify)
- one 'server' api (fastify)

The '/api' route on both clients are expected to point to the same api instance

In production, '/api' on both client apps are routed the api via nginx and docker configuration
In development, I serve both the api and client locally, and use ng serve's proxy config

This means I can avoid having to stream my api data through my client's container. This is especially a win for production environment.

Because of this setup, I do not need to have a separate 'api' route in my client application.

BUT...

When angular tries to build my app, to extract the routes,
- it makes request to the angular engine
- in order to render the app, angular engine needs to make some api calls. Those api calls go to '/api'.
- but there is no nginx config, or proxy config, so it passes the request to the client's fastify instance.
- the client fastify instance does not have a handler for '/api' so it passes the request to the '*' route
- '*' route is handled by.... angular engine

And so it loops and loops.

A. It was not immediately obvious that is a problem of recursion, and not a problem of route not able to render.
B. This is probably behaving as intended. But it forces developers to implement a fallback for api routes, or any other route that is expected on the same origin, just to build in peace. This was not needed before. We did not need to have runtime things available at build-time.
C. Yes, api route example was there in the initial generated server.ts. But it did not tell me "DO NOT DELETE THIS - YOU WILL NEED THIS LATER". Basically, maybe a more thorough documention is in order
D. Alternatively, would it not be great if we configure the build action to pick up proxy information, just like `ng serve`?

----

### Following are the relevant files for the server setup

##### server.ts
```typescript
import { createNodeRequestHandler, isMainModule } from '@angular/ssr/node';
import { serveAngularSSR } from '@easworks/app-shell/utilities/angular-ssr';
import { fastifyCors } from '@fastify/cors';
import { fastify, FastifyInstance } from 'fastify';
import * as path from 'node:path';
import { fileURLToPath } from 'node:url';
import { parseEnv } from 'server-side/environment';
import { useProblemDetailsGlobally } from 'server-side/utils/fastify-problem-details';
import { getLoggerOptions } from 'server-side/utils/logging';
import { printRoutes } from 'server-side/utils/print-routes.plugin';

const envId = parseEnv.nodeEnv();

async function initServer() {
// const options = development ? {} : { http2: true };
const options = {};

const server = fastify({
...options,
logger: getLoggerOptions(envId)
});

return server;
}

async function configureServer(server: FastifyInstance) {

server.register(useProblemDetailsGlobally);
server.register(printRoutes);

server.register(serveAngularSSR, {
directory: path.resolve(fileURLToPath(import.meta.url), '../..'),
});

await server.register(fastifyCors, {
origin: true
});
}

const server = await initServer();
await configureServer(server);

async function closeServer(server: FastifyInstance) {
await server.close();
process.exit();
}

/**
* Start the server if this module is the main entry point.
* The server listens on the port defined by the `PORT` environment variable, or defaults to 4000.
*/
if (isMainModule(import.meta.url)) {
const host = '0.0.0.0';
const port = Number.parseInt(process.env['PORT'] as string);

try {
await server.listen({ host, port });
process.on('SIGTERM', () => closeServer(server));
process.on('SIGINT', () => closeServer(server));
}
catch (e) {
server.log.fatal(e);
closeServer(server);
}
}

/**
* The request handler used by the Angular CLI (dev-server and during build).
*/
export const reqHandler = createNodeRequestHandler(async (req, res) => {
await server.ready();
server.server.emit('request', req, res);
});

```
#### serve-angular-ssr.ts
```typescript
import { AngularNodeAppEngine, writeResponseToNodeResponse } from '@angular/ssr/node';
import { fastifyStatic } from '@fastify/static';
import { FastifyPluginAsync } from 'fastify';
import fastifyPlugin from 'fastify-plugin';
import mime from 'mime';
import * as path from 'path';

interface ServeAngularSSROptions {
directory: string;
}

const pluginImpl: FastifyPluginAsync<
ServeAngularSSROptions
> = async (server, options) => {
const engine = new AngularNodeAppEngine();
const browserDirectory = path.resolve(options.directory, 'browser');

server.register(fastifyStatic, {
root: browserDirectory,
serve: false,
index: false,
redirect: false,
maxAge: '1y',
});

const htmlMime = mime.getType('html');
if (!htmlMime) throw new Error('invalid operation');

server.get('*', async (req, reply) => {

const extension = mime.getType(req.url);

if (extension && req.url !== '/index.html') {
return reply.sendFile(req.url);
} else {
reply.type(htmlMime);
const response = await engine.handle(req.raw);
if (response) return writeResponseToNodeResponse(response, reply.raw);
else return reply.send();
}

});
};

export const serveAngularSSR = fastifyPlugin(pluginImpl, { name: 'serveAngularSSR' });
```

### Describe the solution you'd like

_No response_

### Describe alternatives you've considered

_No response_

Beginne mit dem gemeldeten ng build-Ablauf für outputMode: server und vergleiche ihn mit dem Verhalten der Proxy-Konfiguration von ng serve. Überprüfe den bereitgestellten Request-Handler in server.ts und die Catch-all-Route in serve-angular-ssr.ts, um zu verstehen, wo /api-Anfragen rekursiv werden. Als erledigt gilt dies, wenn der Build Routen extrahieren kann, ohne für diese API-Anfragen einen Application-Fallback zu benötigen.

Vom Indexierungsmodell aus dem Issue-Text verfasst.