[ty] Bare ClassVar annotations (#15768)

## Summary

It was recently clarified in the [typing
spec](https://typing.python.org/en/latest/spec/class-compat.html#classvar)
that bare `ClassVar` annotations are allowed. For annotated assignments
with a right hand side value, the spec requires type checkers to infer
the type as something "to which [the] value is assignable". For a value
of `2`, the spec suggests `int`, `Literal[2]`, or `Any` as examples.
Here, we choose `Unknown | Literal[2]` instead, conforming with out
usual treatment of attribute types.

closes https://github.com/astral-sh/ty/issues/211

crates/ty_python_semantic/src/place.rs

@@ -9,8 +9,8 @@ use crate::semantic_index::{
 };
 use crate::semantic_index::{DeclarationWithConstraint, global_scope, use_def_map};
 use crate::types::{
-    KnownClass, Truthiness, Type, TypeAndQualifiers, TypeQualifiers, UnionBuilder, UnionType,
-    binding_type, declaration_type, todo_type,
+    DynamicType, KnownClass, Truthiness, Type, TypeAndQualifiers, TypeQualifiers, UnionBuilder,
+    UnionType, binding_type, declaration_type, todo_type,
 };
 use crate::{Db, FxOrderSet, KnownModule, Program, resolve_module};
 
@@ -672,6 +672,30 @@ fn place_by_id<'db>(
             .with_qualifiers(qualifiers);
     }
 
+    // Handle bare `ClassVar` annotations by falling back to the union of `Unknown` and the
+    // inferred type.
+    match declared {
+        Ok(PlaceAndQualifiers {
+            place: Place::Type(Type::Dynamic(DynamicType::Unknown), declaredness),
+            qualifiers,
+        }) if qualifiers.contains(TypeQualifiers::CLASS_VAR) => {
+            let bindings = all_considered_bindings();
+            match place_from_bindings_impl(db, bindings, requires_explicit_reexport) {
+                Place::Type(inferred, boundness) => {
+                    return Place::Type(
+                        UnionType::from_elements(db, [Type::unknown(), inferred]),
+                        boundness,
+                    )
+                    .with_qualifiers(qualifiers);
+                }
+                Place::Unbound => {
+                    return Place::Type(Type::unknown(), declaredness).with_qualifiers(qualifiers);
+                }
+            }
+        }
+        _ => {}
+    }
+
     match declared {
         // Place is declared, trust the declared type
         Ok(