[ty] Prefer declared type for invariant collection literals (#20927)

## Summary

Prefer the declared type for collection literals, e.g.,
```py
x: list[Any] = [1, "2", (3,)]
reveal_type(x)  # list[Any]
```

This solves a large part of https://github.com/astral-sh/ty/issues/136
for invariant generics, where respecting the declared type is a lot more
important. It also means that annotated dict literals with `dict[_,
Any]` is a way out of https://github.com/astral-sh/ty/issues/1248.

crates/ty_python_semantic/src/types/display.rs

@@ -591,7 +591,15 @@ impl Display for DisplayRepresentation<'_> {
                 .0
                 .display_with(self.db, self.settings.clone())
                 .fmt(f),
-            Type::TypeAlias(alias) => f.write_str(alias.name(self.db)),
+            Type::TypeAlias(alias) => {
+                f.write_str(alias.name(self.db))?;
+                match alias.specialization(self.db) {
+                    None => Ok(()),
+                    Some(specialization) => specialization
+                        .display_short(self.db, TupleSpecialization::No, self.settings.clone())
+                        .fmt(f),
+                }
+            }
         }
     }
 }

crates/ty_python_semantic/src/types/infer/builder.rs

@@ -6179,6 +6179,13 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
 
                 let inferred_elt_ty = self.get_or_infer_expression(elt, elt_tcx);
 
+                // Simplify the inference based on the declared type of the element.
+                if let Some(elt_tcx) = elt_tcx.annotation {
+                    if inferred_elt_ty.is_assignable_to(self.db(), elt_tcx) {
+                        continue;
+                    }
+                }
+
                 // Convert any element literals to their promoted type form to avoid excessively large
                 // unions for large nested list literals, which the constraint solver struggles with.
                 let inferred_elt_ty = inferred_elt_ty.promote_literals(self.db(), elt_tcx);