perf: memoize cql_parameterized_type() on all type classes

Cache the computed CQL type string in a _cql_type_str class attribute.
The string is computed lazily on first call and returned from cache on
subsequent calls.  Since type classes are immutable after
apply_parameters(), no invalidation logic is needed.

All 6 cql_parameterized_type() overrides are covered:
  _CassandraType (base), TupleType, UserType, CompositeType,
  DynamicCompositeType, VectorType.

Benchmark (500k iters, Python 3.14):
  Int32Type (simple):         6.9x  (157 -> 23 ns)
  MapType<text, int>:        22.9x  (464 -> 20 ns)
  SetType<float>:            18.2x  (371 -> 20 ns)
  ListType<double>:          17.3x  (357 -> 21 ns)
  TupleType<int,text,bool>:  25.0x  (509 -> 20 ns)
  Nested map/list/tuple:     11.4x  (636 -> 56 ns)

Author: mykaul

cassandra/cqltypes.py

@@ -314,6 +314,11 @@ class _CassandraType(object, metaclass=CassandraTypeType):
     num_subtypes = 0
     empty_binary_ok = False
 
+    # Cached result of cql_parameterized_type(). Computed lazily on first
+    # access and stored as a class attribute. Safe because type classes are
+    # immutable after creation via apply_parameters().
+    _cql_type_str = None
+
     support_empty_values = False
     """
     Back in the Thrift days, empty strings were used for "null" values of
@@ -428,12 +433,18 @@ def cql_parameterized_type(cls):
         Return a CQL type specifier for this type. If this type has parameters,
         they are included in standard CQL <> notation.
         """
+        result = cls._cql_type_str
+        if result is not None:
+            return result
         if not cls.subtypes:
-            return cls.typename
-        return "%s<%s>" % (
-            cls.typename,
-            ", ".join(styp.cql_parameterized_type() for styp in cls.subtypes),
-        )
+            result = cls.typename
+        else:
+            result = "%s<%s>" % (
+                cls.typename,
+                ", ".join(styp.cql_parameterized_type() for styp in cls.subtypes),
+            )
+        cls._cql_type_str = result
+        return result
 
     @classmethod
     def cass_parameterized_type(cls, full=False):
@@ -1042,10 +1053,15 @@ def serialize_safe(cls, val, protocol_version):
 
     @classmethod
     def cql_parameterized_type(cls):
+        result = cls._cql_type_str
+        if result is not None:
+            return result
         subtypes_string = ", ".join(
             sub.cql_parameterized_type() for sub in cls.subtypes
         )
-        return "frozen<tuple<%s>>" % (subtypes_string,)
+        result = "frozen<tuple<%s>>" % (subtypes_string,)
+        cls._cql_type_str = result
+        return result
 
 
 class UserType(TupleType):
@@ -1102,7 +1118,12 @@ def apply_parameters(cls, subtypes, names):
 
     @classmethod
     def cql_parameterized_type(cls):
-        return "frozen<%s>" % (cls.typename,)
+        result = cls._cql_type_str
+        if result is not None:
+            return result
+        result = "frozen<%s>" % (cls.typename,)
+        cls._cql_type_str = result
+        return result
 
     @classmethod
     def deserialize_safe(cls, byts, protocol_version):
@@ -1182,8 +1203,13 @@ def cql_parameterized_type(cls):
         """
         There is no CQL notation for Composites, so we override this.
         """
+        result = cls._cql_type_str
+        if result is not None:
+            return result
         typestring = cls.cass_parameterized_type(full=True)
-        return "'%s'" % (typestring,)
+        result = "'%s'" % (typestring,)
+        cls._cql_type_str = result
+        return result
 
     @classmethod
     def deserialize_safe(cls, byts, protocol_version):
@@ -1208,11 +1234,16 @@ class DynamicCompositeType(_ParameterizedType):
 
     @classmethod
     def cql_parameterized_type(cls):
+        result = cls._cql_type_str
+        if result is not None:
+            return result
         sublist = ", ".join(
             "%s=>%s" % (alias, typ.cass_parameterized_type(full=True))
             for alias, typ in zip(cls.fieldnames, cls.subtypes)
         )
-        return "'%s(%s)'" % (cls.typename, sublist)
+        result = "'%s(%s)'" % (cls.typename, sublist)
+        cls._cql_type_str = result
+        return result
 
 
 class ColumnToCollectionType(_ParameterizedType):
@@ -1655,8 +1686,13 @@ def serialize(cls, v, protocol_version):
 
     @classmethod
     def cql_parameterized_type(cls):
-        return "%s<%s, %s>" % (
+        result = cls._cql_type_str
+        if result is not None:
+            return result
+        result = "%s<%s, %s>" % (
             cls.typename,
             cls.subtype.cql_parameterized_type(),
             cls.vector_size,
         )
+        cls._cql_type_str = result
+        return result