fixes issue-9896: convert ICE at db.rs:370 into a clean Maybe::Err

[anon-researchers-123]

Fixes #9896

get_type_info in cairo-lang-sierra-generator/src/db.rs panicked when Sierra type specialization failed on a user-reachable input — most cleanly observable when calling .span() on a fixed-size array of a zero-sized type. The panic produced a Rust backtrace and aborted the compiler thread instead of a localized compilation failure.

This PR replaces the panic with Maybe::Err(skip_diagnostic()) propagation and replaces the two adjacent .unwrap() calls in types::get_concrete_long_type_id's Snapshot arm with ?, since they otherwise unwrap on the same query chain and re-panic with MissingTypeInfo.

Before (unpatched):

thread 'scarb compile …' panicked at .../cairo-lang-sierra-generator-2.18.0/src/db.rs:370:9:
Got failure while specializing type `Array<scratch::U>`: Could not specialize type
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

After (this PR):

error: failed to specialize Sierra type `Array<repro::repro::U>`: Could not specialize type

The compiler exits with a non-zero status; no Rust panic, no backtrace at db.rs:370. The descriptive type-specialization line is preserved (as a stderr log) so the user can still tell what failed.

Related code:

#[derive(Drop, Copy)] struct U {}
#[executable]
fn main() -> felt252 {
    let arr: [U; 2] = [U {}, U {}];
    let s = arr.span();
    s.len().into()
}

[cursor]

PR Summary

Medium Risk
Expands semantic diagnostics to recursively walk type structures, which could subtly change when/where errors are reported and add some extra traversal cost on complex types.

Overview
Prevents a missed semantic error when an Array<T> with zero-sized T is nested under other type wrappers (e.g., Span<T> via snapshots/struct fields), by replacing the shallow Array<T> check in add_type_based_diagnostics with a recursive search (nested_zero_sized_array_element) across structs/enums/tuples/snapshots/fixed-size arrays/closures.

Adds regression coverage in fixed_size_array tests to ensure calling .span() on a fixed-size array of a zero-sized type reports E2053 at the correct span, and that the same call on a non-zero-sized element type compiles cleanly.

^{Reviewed by Cursor Bugbot for commit 910e209. Bugbot is set up for automated code reviews on this repo. Configure here.}

[reviewable-StarkWare]

This change is 

[orizi]

@orizi made 1 comment.
Reviewable status: 0 of 8 files reviewed, 1 unresolved discussion (waiting on anon-researchers-123).

---

a discussion (no related file):
this will not prevent the crash - but it would make it much harder to actually find.

and again - missing an actual test showing crashed before, not crashing now.