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_

Comece com o fluxo reportado de ng build para outputMode: server e compare-o com o comportamento da configuração de proxy do ng serve. Revise o handler de requisições fornecido em server.ts e a rota catch-all de serve-angular-ssr.ts para entender onde as requisições /api entram em recursão. Considera-se concluído quando o build puder extrair rotas sem exigir um fallback da aplicação para essas requisições de API.

Escrita pelo modelo de indexação a partir do texto da issue.