text: Title: Support generic types for `union` and `union_all`
  Body: ### Describe the use case
  
  For `union` and `union_all` which both have signatures that accept multiple `Select`s, the generic type information is lost in the union query. Ideally the return type of these functions should be the most specific supertype of each of the input `Select`s.
  
  ### Databases / Backends / Drivers targeted
  
  I don't think this covers any specific drivers or backends.
  
  ### Example Use
  
  Here's an example that shows how this addition to typing could help to catch a programming error:
  
  ```python
  from typing import Any, TypeVar
  
  from sqlalchemy import select
  from sqlalchemy.orm import Session
  from sqlalchemy.sql.elements import ColumnElement
  from sqlalchemy.sql.expression import union
  from sqlalchemy.sql.selectable import Select
  
  sess: Session
  str_c: ColumnElement[str]
  int_c: ColumnElement[int]
  
  q1 = select(str_c, int_c)
  cursor1 = sess.execute(q1).tuples()
  reveal_type(cursor1)  # example.py:15: note: Revealed type is "sqlalchemy.engine.result.TupleResult[tuple[builtins.str, builtins.int]]"
  for row1 in cursor1:
      x1: int
      y1: str
      x1, y1 = row1  # example.py:19: error: Incompatible types in assignment (expression has type "str", variable has type "int")  [assignment] example.py:19: error: Incompatible types in assignment (expression has type "int", variable has type "str")  [assignment]
  
  q2 = select(str_c, int_c)
  union_query = union(q1, q2)
  
  cursor2 = sess.execute(union_query).tuples()
  reveal_type(cursor2)  # example.py:25: note: Revealed type is "sqlalchemy.engine.result.TupleResult[Any]"
  for row2 in cursor2:
      x2: int
      y2: str
      x2, y2 = row2  # this should be a typing error
  
  
  T = TypeVar("T", bound=tuple[Any, ...])
  
  # define a union function that takes selects with generic types
  def example_union(*selects: Select[T]) -> Select[T]: ...  # type: ignore[empty-body]
  
  
  example_union_query = example_union(q1, q2)
  cursor3 = sess.execute(example_union_query).tuples()
  reveal_type(cursor3)  # example.py:40: note: Revealed type is "sqlalchemy.engine.result.TupleResult[tuple[builtins.str, builtins.int]]"
  for row3 in cursor3:
      x3: int
      y3: str
      x3, y3 = row3  # example.py:44: error: Incompatible types in assignment (expression has type "str", variable has type "int")  [assignment] example.py:44: error: Incompatible types in assignment (expression has type "int", variable has type "str")  [assignment]
  ```
  
  ### Additional context
  
  _No response_