fix(e2e): let web-e2e:e2e run outside CI

Without CI, every web-e2e webServer has reuseExistingServer, so
@nx/playwright infers a continuous web:serve dependency for the
`pnpm nx run web:serve` entry. The mocks and the web backend launch as
plain node processes with env, which no Nx task covers, so the plugin
also marks the target non-parallel. Nx refuses a non-parallel task with
continuous dependencies, and `nx run web-e2e:e2e` failed before running
anything; CI passed only because CI=1 disables reuse and with it the
inferred dependency.

Give web-e2e:e2e an empty dependsOn so Playwright starts every server,
as it already does in CI. The Angular dev-server runs inside the Nx
process, so Playwright's process-group kill still stops it. Turn off
the plugin's readiness gate, which no target consumes any more.

Add `pnpm run e2e:task-graphs:validate`: it builds every Playwright
target's task graph with Nx's own validation, with CI unset and set,
and runs in the unit-and-typecheck job.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tools/nx/check-e2e-task-graphs.test.mjs

@@ -0,0 +1,78 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+
+import {
+    findInvalidTaskGraphs,
+    MODES,
+    playwrightTargets,
+} from './check-e2e-task-graphs.mjs';
+
+const playwright = { technologies: ['playwright'] };
+
+/**
+ * Mirrors web-e2e as the Playwright plugin infers it without CI: an uncovered
+ * mock webServer makes `e2e` non-parallel while `pnpm nx run web:serve` adds a
+ * continuous dependency on the dev server.
+ */
+function graphWithE2eTarget(e2eTarget) {
+    const node = (name, targets) => ({
+        name,
+        type: 'app',
+        data: { root: `apps/${name}`, targets },
+    });
+    return {
+        nodes: {
+            web: node('web', {
+                serve: {
+                    executor: '@angular/build:dev-server',
+                    continuous: true,
+                },
+            }),
+            'web-e2e': node('web-e2e', {
+                e2e: {
+                    executor: 'nx:run-commands',
+                    options: { command: 'playwright test' },
+                    metadata: playwright,
+                    ...e2eTarget,
+                },
+                lint: {
+                    executor: '@nx/eslint:lint',
+                    parallelism: false,
+                    dependsOn: [{ projects: ['web'], target: 'serve' }],
+                },
+            }),
+        },
+        dependencies: { web: [], 'web-e2e': [] },
+    };
+}
+
+test('checks only Playwright-inferred targets', () => {
+    const graph = graphWithE2eTarget({ parallelism: false });
+
+    assert.deepEqual(playwrightTargets(graph), [
+        { project: 'web-e2e', target: 'e2e' },
+    ]);
+});
+
+test('reports a non-parallel e2e target that depends on a continuous serve', async () => {
+    const graph = graphWithE2eTarget({
+        parallelism: false,
+        dependsOn: [{ projects: ['web'], target: 'serve' }],
+    });
+
+    const failures = await findInvalidTaskGraphs(graph);
+
+    assert.equal(failures.length, 1);
+    assert.equal(failures[0].task, 'web-e2e:e2e');
+    assert.match(failures[0].message, /web-e2e:e2e -> web:serve/);
+});
+
+test('accepts a non-parallel e2e target whose servers Playwright starts', async () => {
+    const graph = graphWithE2eTarget({ parallelism: false, dependsOn: [] });
+
+    assert.deepEqual(await findInvalidTaskGraphs(graph), []);
+});
+
+test('validates both the local and the CI plugin inference', () => {
+    assert.deepEqual(MODES, { local: { CI: undefined }, ci: { CI: 'true' } });
+});