Issue Proposal: Rust compiler logs invariant errors with a different event shape than the TS reference

Summary

The Rust port of the React Compiler emits CompileError logger events whose detail
shape differs from the TypeScript reference for errors thrown as CompilerError.invariant()
during lowering. Concretely, the Rust event carries the error inside a nested
detail.details[0] array, while the TS reference places the location directly on
detail.loc. This fails the e2e event comparison for the fixture
error.bug-invariant-couldnt-find-binding-for-decl.js.

This is the only remaining Rust-vs-TS event-shape failure in the Babel e2e suite
(1807 / 1810 total; the other two failures are the already-documented, accepted
fixture differences in TODO.md Group A).

Profiling evidence

Full Babel e2e run at HEAD f1f7ed2ac:

Code: 1809/1810 passed   Events: 1807/1810 passed   Total: 1807/1810 passed

FAIL compiler/.../fixtures/compiler/error.bug-invariant-couldnt-find-binding-for-decl.js

Fixture input:

import {useEffect} from 'react';

export function Foo() {
  useEffect(() => {
    try {
      // do something
    } catch ({status}) {
      // do something
    }
  }, []);
}

Raw detail payloads logged by each implementation for the same input:

field	TS reference	Rust
detail.category	"Invariant"	"Invariant"
detail.reason	"(BuildHIR::lowerAssignment) Could not find binding for declaration."	same
detail.severity	"Error"	"Error"
detail.loc	{start, end, identifierName: "status"}	(absent)
detail.details	(absent)	[{kind: "error", loc: {start, end}, message: "..."}]

The emitted code and fnLoc are identical; only the event detail shape diverges.

Root cause

Both implementations already serialize each diagnostic faithfully — the Rust
log_error/compiler_error_to_info paths in
compiler/crates/react_compiler/src/entrypoint/program.rs mirror the TS
formatDetailForLogging (src/Entrypoint/Program.ts:177), which maps
CompilerDiagnostic → detail.details[] and CompilerErrorDetail → flat detail.loc.

The divergence originates earlier, in the error-type conversion:

compiler/crates/react_compiler_lowering/src/build_hir.rs:3942
records the catch-binding failure as an CompilerErrorDetail (category Invariant).
builder.record_error(...) returns Err(CompilerError) for invariant errors
(compiler/crates/react_compiler_hir/src/environment.rs:331). The enclosing function
returns Result<T, CompilerDiagnostic>, so the ? operator triggers

impl From<CompilerError> for CompilerDiagnostic
(compiler/crates/react_compiler_diagnostics/src/lib.rs:385),

which wraps the ErrorDetail via CompilerDiagnostic::from_detail(...). A
CompilerDiagnostic always serializes as the detail.details[] form, so the flat
location that TS preserves on the CompilerErrorDetail is moved into a sub-detail.

In TS, the equivalent CompilerError.invariant() produces a CompilerErrorDetail
(src/HIR/BuildHIR.ts:948), which survives to the logger as the flat detail.loc
form.

Proposed minimal fix (for discussion)

Keep the invariant error's ErrorDetail representation through the ? conversion so
the logged event stays flat, matching TS. The forward conversion currently always calls
from_detail; the reverse conversion already special-cases flat output for the Todo
category (see the comment at compiler/crates/react_compiler_diagnostics/src/lib.rs:405).
Extending the same principle to the invariant path in the forward conversion would align
the emitted event shape without touching serialization call sites or fixture outputs.

Scope is intentionally limited to:

• compiler/crates/react_compiler_diagnostics/src/lib.rs (the From conversion)
• a regression test (below)

No change to log_error, compiler_error_to_info, the Babel/NAPI bridge, or any
.expect.md fixture is expected. Codegen output and fnLoc are unaffected (only the
event detail shape changes), so no other fixture should change.

Regression test plan

1. Unit test (fast, no JS toolchain): a test in
   compiler/crates/react_compiler_diagnostics (or react_compiler_lowering) asserting
   that converting a single-invariant CompilerError to CompilerDiagnostic and then
   serializing through log_error's detail path yields detail.loc populated and
   detail.details absent. The test fails on current main and passes after the fix.
2. E2E gate: bash compiler/scripts/test-e2e.sh --variant babel must move
   error.bug-invariant-couldnt-find-binding-for-decl.js from FAIL to PASS while
   keeping the other 1809 fixtures passing.
3. Workspace unit tests: cargo test --workspace (currently 84 passed, 0 failed)
   must stay green.

Compatibility

• Backward compatible: this only changes the serialized shape of a diagnostic that
  currently diverges from the reference; the emitted program is unchanged.
• No public API change: the conversion is internal to the compiler crates.

Verification environment

• HEAD: f1f7ed2ac ([rust-compiler] Preserve ref access location across phi joins)
• Rust toolchain 1.97.1, edition 2024, rust-version = 1.85
• Babel e2e variant only; SWC/OXC frontends are not present on main.