perf: pre-allocate buffer in VectorType.serialize for fixed-size elements

When subtype.serial_size() is known (e.g. FloatType, DoubleType,
Int32Type), pre-allocate a bytearray of exact size and write elements
via slice assignment instead of using io.BytesIO with dynamic growth.

This avoids BytesIO's internal buffer reallocation overhead for the
common case of fixed-size vector elements. Variable-size elements
continue to use BytesIO with uvint length prefixes.

Author: mykaul

cassandra/cqltypes.py

@@ -1483,13 +1483,24 @@ def serialize(cls, v, protocol_version):
                 .format(cls.vector_size, cls.subtype.typename, v_length))
 
         serialized_size = cls.subtype.serial_size()
-        buf = io.BytesIO()
-        for item in v:
-            item_bytes = cls.subtype.serialize(item, protocol_version)
-            if serialized_size is None:
+        if serialized_size is not None:
+            # Fixed-size elements: pre-allocate exact buffer, write directly
+            total = serialized_size * v_length
+            buf = bytearray(total)
+            offset = 0
+            for item in v:
+                item_bytes = cls.subtype.serialize(item, protocol_version)
+                buf[offset:offset + serialized_size] = item_bytes
+                offset += serialized_size
+            return bytes(buf)
+        else:
+            # Variable-size elements: use BytesIO with uvint length prefix
+            buf = io.BytesIO()
+            for item in v:
+                item_bytes = cls.subtype.serialize(item, protocol_version)
                 buf.write(uvint_pack(len(item_bytes)))
-            buf.write(item_bytes)
-        return buf.getvalue()
+                buf.write(item_bytes)
+            return buf.getvalue()
 
     @classmethod
     def cql_parameterized_type(cls):