perf(bundle): lazy-load the nunjucks template engine (#2535)

Closes #2531.

## Summary

The full `nunjucks` templating engine (~226KB) plus `ha-nunjucks`
(~46KB) — roughly **272KB, ~13% of the eager entry chunk** — was
statically imported and downloaded by every card on initial load, even
though templates only apply when a config value contains a `{{ … }}` /
`{% … %}` delimiter. Most cards use no templates and never need the
engine.

This defers the engine behind a dynamic `import('ha-nunjucks/dist')` so
it ships in a separate, on-demand chunk instead of the eager
`card-*.js`.

## Approach

The render path (`TemplateRenderer.renderRecursively`) is **kept
synchronous** — it is called from many synchronous hot paths
(condition/trigger evaluators, picture-elements rendering, actions,
folder matchers), and making it async would be a large, high-risk
refactor of the evaluation core.

Instead:

- **New `src/card-controller/templates/engine.ts`** — a module-level
singleton lazy loader (`loadTemplateEngine()` / `getTemplateEngine()`)
shared across all `TemplateRenderer` instances, plus a
`containsTemplate()` delimiter helper.
- **Delimiter gating** — strings without a delimiter never touch the
engine (the overwhelming majority of renders).
- **Pre-warm at config time** — because every template string originates
in the config, a new mandatory `TEMPLATE_ENGINE` initialization aspect
loads the engine before first render whenever the config contains a
delimiter. This **guarantees no raw `{{ … }}` flash**: content/condition
rendering is blocked until the engine is present for template-using
cards. Cards without templates never load it.

## Result

- nunjucks + ha-nunjucks move out of the eager chunk into a separate
chunk fetched only when a card actually uses templates.
- No change to the synchronous public render API; condition/trigger
evaluation core untouched.

## Tests

- New `engine.ts` loader coverage (concurrent load, cached reuse,
not-loaded fallback).
- The 11 existing test files that render real (delimiter-bearing)
templates declare their dependency explicitly via
`beforeAll(loadTemplateEngine)` — no global/implicit setup hook.
- Full suite green (4764 tests), lint and ts-prune clean, per-file 100%
coverage maintained for the affected directories.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

https://claude.ai/code/session_016ykWemdkZrgywvC71pHc6c

---
_Generated by [Claude
Code](https://claude.ai/code/session_016ykWemdkZrgywvC71pHc6c)_

tests/condition-trigger/conditions/conditions/numeric-state.test.ts

@@ -1,7 +1,12 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 
+import { TemplateManager } from '../../../../src/card-controller/templates';
 import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
-import { createHASS, createStateEntity } from '../../../test-utils';
+import {
+  createHASS,
+  createMockTemplateRenderer,
+  createStateEntity,
+} from '../../../test-utils';
 import { createEvaluatorContext } from './test-utils';
 
 // @vitest-environment jsdom
@@ -122,7 +127,12 @@ describe('numeric state condition', () => {
     ).toBeFalsy();
   });
 
-  it('should compare the rendered value_template instead of the state', () => {
+  it('should compare the rendered value_template instead of the state', async () => {
+    // This case renders a real value_template, so load the lazily-imported
+    // engine for the synchronous renderer.
+    const templateManager = new TemplateManager();
+    await templateManager.loadRenderer();
+
     const evaluator = createConditionEvaluator(
       {
         condition: 'numeric_state' as const,
@@ -130,7 +140,7 @@ describe('numeric state condition', () => {
         value_template: '{{ 11 }}',
         above: 10,
       },
-      createEvaluatorContext(),
+      createEvaluatorContext({ templateRenderer: templateManager }),
     );
 
     // The entity state (0) would fail; the template value (11) passes.
@@ -141,6 +151,28 @@ describe('numeric state condition', () => {
     ).toBeTruthy();
   });
 
+  it('should not match a value_template until the renderer has loaded', () => {
+    const unloadedRenderer = createMockTemplateRenderer();
+    vi.mocked(unloadedRenderer).isLoaded.mockReturnValue(false);
+    const evaluator = createConditionEvaluator(
+      {
+        condition: 'numeric_state' as const,
+        entity_id: 'sensor.foo',
+        value_template: '{{ 11 }}',
+        above: 10,
+      },
+      createEvaluatorContext({ templateRenderer: unloadedRenderer }),
+    );
+
+    // The entity state (11) would pass, but the value_template cannot be
+    // evaluated before the renderer loads, so the condition does not match.
+    expect(
+      evaluator.evaluate({
+        hass: createHASS({ 'sensor.foo': createStateEntity({ state: '11' }) }),
+      }).result,
+    ).toBeFalsy();
+  });
+
   it('should not match when the value is not numeric', () => {
     const evaluator = createConditionEvaluator(
       { condition: 'numeric_state' as const, entity_id: 'sensor.foo', above: 10 },