text: Title: Permanently corrupted hybrid_property column labeling as a result of selecting column returned by hybrid_property.expression
  Body: ### Describe the bug
  
  The issue causes a select of `hybrid_property` to return its value under wrong label. The ORM model becomes "corrupted" by construction of a different specific select, selecting the column returned by `hybrid_property.expression`. The select causes memoization of `_proxy_key`, which is then incorrectly used as label of the column in the corrupted select.
  
  `select(Model.id)` will return the `id` hybrid_property under `_id` key which is the name of the column returned by `hybrid_property.expression` of the `id` hybrid_property.
  
  We have found this issue during migration of a large codebase from SQLAlchemy `1.3` to `1.4`, we will be thankful for a `1.4` fix.
  
  ### Optional link from https://docs.sqlalchemy.org which documents the behavior that is expected
  
  _No response_
  
  ### SQLAlchemy Version in Use
  
  1.4.52, 2.0.32
  
  ### DBAPI (i.e. the database driver)
  
  Any, psycopg2
  
  ### Database Vendor and Major Version
  
  Any, PostgreSQL 15
  
  ### Python Version
  
  3.11, Any
  
  ### Operating system
  
  Windows, Any
  
  ### To Reproduce
  
  ```python
  from sqlalchemy import Column, select
  from sqlalchemy.dialects.postgresql import UUID
  from sqlalchemy.ext.hybrid import hybrid_property
  from sqlalchemy.orm import declarative_base
  
  Base = declarative_base()
  
  
  class Model(Base):
      __tablename__ = 'model'
  
      _id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
  
      @hybrid_property
      def id(self):
          return self._id
  
      @id.expression
      def id(cls):
          return cls._id
  
  
  assert select(Model.id).subquery().c[0].key == 'id' and Model.id.expression._proxy_key == 'id'
  
  assert select(Model._id).subquery().c[0].key == '_id'
  # Creating above select causes the first select to fail when repeated.
  # Selecting the underscored hybrid.expression's "target" Column causes
  # memoization of `_proxy_key` in `Model._id.__clause_element__().__dict__`
  # As a consequence column `id` is returned under name `_id` in the result rows
  # instead of the expected `id`.
  # Presence of the memoized `_proxy_key` in __dict__ causes it to be cloned
  # in `sqlalchemy_sql_annotation_annotated._with_annotations`
  # and it takes precedence when accessed via the Proxy class of hybrid property
  # during select construction.
  
  # The broken memoized state can be reverted by deleting memoized `_proxy_key` using following line
  # del Model._id.__clause_element__().__dict__['_proxy_key']
  
  assert (
      select(Model.id).subquery().c[0].key == 'id'
  ), "Resulting `id` column would be returned incorrectly under `_id` attribute/key."
  assert Model.id.expression._proxy_key == 'id'
  ```
  
  
  ### Error
  
  ```
  # No exceptions
  ``` 
  
  ### Additional context
  
  _No response_