Have USE_SHELL warn but work like normal via super()

This reimplements Git.USE_SHELL with no properties or descriptors.
The metaclass is still needed, but instad of defining properties it
defines __getattribute__ and __setattr__, which check for USE_SHELL
and warn, then invoke the default attribute access via super().

Likewise, in the Git class itself, a __getatttribute__ override is
introduced (not to be confused with __getattr__, which was already
present and handles attribute access when an attribute is otherwise
absent, unlike __getattribute__ which is always used). This checks
for reading USE_SHELL on an instance and warns, then invokes the
default attribute access via super().

Advantages:

- Git.USE_SHELL is again unittest.mock.patch patchable.

- AttributeError messages are automatically as before.

- It effectively is a simple attribute, yet with warning, so other
  unanticipated ways of accessing it may be less likely to break.

- The code is simpler, cleaner, and clearer. There is some
  overhead, but it is small, especially compared to a subprocess
  invocation as is done for performing most git operations.

However, this does introduce disadvantages that must be addressed:

- Although attribute access on Git instances was already highly
  dynamic, as "methods" are synthesized for git subcommands, this
  was and is not the case for the Git class itself, whose
  attributes remain exactly those that can be inferred without
  considering the existence of __getattribute__ and __setattr__ on
  the metaclass. So static type checkers need to be prevented from
  accounting for those metaclass methods in a way that causes them
  to infer that arbitrary class attribute access is allowed.

- The occurrence of Git.USE_SHELL in the Git.execute method (where
  the USE_SHELL attribute is actually examined) should be changed
  so it does not itself issue DeprecationWarning (it is not enough
  that by default a DeprecationWarning from there isn't displayed).

git/cmd.py

@@ -55,7 +55,6 @@
     TYPE_CHECKING,
     TextIO,
     Tuple,
-    Type,
     Union,
     cast,
     overload,
@@ -336,15 +335,15 @@ class _GitMeta(type):
     This helps issue :class:`DeprecationWarning` if :attr:`Git.USE_SHELL` is used.
     """
 
-    @property
-    def USE_SHELL(cls: Type[Git]) -> bool:
-        _warn_use_shell(False)
-        return cls._USE_SHELL
+    def __getattribute__(cls, name: str) -> Any:
+        if name == "USE_SHELL":
+            _warn_use_shell(False)
+        return super().__getattribute__(name)
 
-    @USE_SHELL.setter
-    def USE_SHELL(cls: Type[Git], value: bool) -> None:
-        _warn_use_shell(value)
-        cls._USE_SHELL = value
+    def __setattr__(cls, name: str, value: Any) -> Any:
+        if name == "USE_SHELL":
+            _warn_use_shell(value)
+        super().__setattr__(name, value)
 
 
 class Git(metaclass=_GitMeta):
@@ -397,9 +396,7 @@ def __setstate__(self, d: Dict[str, Any]) -> None:
     GIT_PYTHON_TRACE = os.environ.get("GIT_PYTHON_TRACE", False)
     """Enables debugging of GitPython's git commands."""
 
-    _USE_SHELL: bool = False
-
-    USE_SHELL: bool
+    USE_SHELL: bool = False
     """Deprecated. If set to ``True``, a shell will be used to execute git commands.
 
     Prior to GitPython 2.0.8, this had a narrow purpose in suppressing console windows
@@ -909,6 +906,11 @@ def __init__(self, working_dir: Union[None, PathLike] = None) -> None:
         self.cat_file_header: Union[None, TBD] = None
         self.cat_file_all: Union[None, TBD] = None
 
+    def __getattribute__(self, name: str) -> Any:
+        if name == "USE_SHELL":
+            _warn_use_shell(False)
+        return super().__getattribute__(name)
+
     def __getattr__(self, name: str) -> Any:
         """A convenience method as it allows to call the command as if it was an object.
 
@@ -918,11 +920,6 @@ def __getattr__(self, name: str) -> Any:
         """
         if name.startswith("_"):
             return super().__getattribute__(name)
-
-        if name == "USE_SHELL":
-            _warn_use_shell(False)
-            return self._USE_SHELL
-
         return lambda *args, **kwargs: self._call_process(name, *args, **kwargs)
 
     def set_persistent_git_options(self, **kwargs: Any) -> None:
@@ -1184,7 +1181,7 @@ def execute(
 
         stdout_sink = PIPE if with_stdout else getattr(subprocess, "DEVNULL", None) or open(os.devnull, "wb")
         if shell is None:
-            shell = self._USE_SHELL
+            shell = self.USE_SHELL
         _logger.debug(
             "Popen(%s, cwd=%s, stdin=%s, shell=%s, universal_newlines=%s)",
             redacted_command,