Fix codegen crashes for intersection types and complex list inner types (#172)

Why
===



Codegen fails when a schema contains intersection types (`allOf`) or
lists with complex inner types (e.g. `list[dict[str, Any]]`). Both crash
with `Complex type must be put through render_type_expr!` or `Unexpected
expression when expecting a type name: DictTypeExpr(...)` because
`TypeName` objects are used directly in f-strings or passed to
`ensure_literal_type` which only accepts simple `TypeName` values.

What changed
============



- Fix `TypeName.__str__()` crash in the `RiverIntersectionType` encoder
by wrapping `encoder_name` with `render_literal_type()`, matching the
existing pattern used by `RiverUnionType` (line 625) and
`RiverConcreteType` (line 654)
- Fix `ensure_literal_type` crash when a list's inner type is a complex
expression (e.g. `list[dict[str, Any]]`) by guarding the `ListTypeExpr`
match to only enter the encoding branch for `TypeName` inner types,
falling through to `list(x)` for composite types that don't need
encoding

Test plan
=========

_Describe what you did to test this change to a level of detail that
allows your reviewer to test it_

Author: daweifeng-replit

src/replit_river/codegen/client.py

@@ -407,7 +407,9 @@ def {_field_name}(
                     encoder_parts.append(("isinstance(x, str)", "x"))
                 elif t.type == "array":
                     match type_name:
-                        case ListTypeExpr(inner_type_name):
+                        case ListTypeExpr(inner_type_name) if isinstance(
+                            inner_type_name, TypeName
+                        ):
                             # Primitives don't need encoding
                             inner_type_str = render_literal_type(inner_type_name)
                             if inner_type_str in ("str", "int", "float", "bool", "Any"):
@@ -633,7 +635,9 @@ def extract_props(tpe: RiverType) -> list[dict[str, RiverType]]:
                             f"encode_{render_literal_type(type_name)}"
                         )
                         encoder_names.add(encoder_name)
-                        typeddict_encoder.append(f"{encoder_name}(x[{repr(name)}])")
+                        typeddict_encoder.append(
+                            f"{render_literal_type(encoder_name)}(x[{repr(name)}])"
+                        )
                     elif isinstance(prop, RiverConcreteType):
                         if name == "$kind":
                             safe_name = "kind"