refactor: Use final target in alias proxies

The previous comment stating that we should not use
the final target because it could be of another kind
than the first target makes no sense. If the first target
is an alias, then accessing its proxy would access the
next one, until the final target one is reached.
Aliases chains are just that: chains of aliases
with a concrete object at the end. There cannot be
a concrete object in the middle, therefore there
cannot be different kinds in a chain, only aliases
and a single kind at the end.

src/griffe/dataclasses.py

@@ -1013,16 +1013,16 @@ def del_member(self, key: str | Sequence[str]) -> None: # noqa: D102
 
  # SPECIFIC MODULE/CLASS/FUNCTION/ATTRIBUTE PROXIES ---------------
  # These methods and properties exist on targets of specific kind.
- # We have to call the method/property on the first target, not the final one
- # (which could be of another kind).
+ # We first try to reach the final target, trigerring alias resolution errors
+ # and cyclic aliases errors early. We avoid recursing in the alias chain.
 
  @property
  def _filepath(self) -> Path | list[Path] | None:
- return cast(Module, self.target)._filepath
+ return cast(Module, self.final_target)._filepath
 
  @property
  def bases(self) -> list[Expr | str]: # noqa: D102
- return cast(Class, self.target).bases
+ return cast(Class, self.final_target).bases
 
  @property
  def decorators(self) -> list[Decorator]: # noqa: D102
@@ -1054,43 +1054,43 @@ def is_namespace_subpackage(self) -> bool: # noqa: D102
 
  @property
  def overloads(self) -> dict[str, list[Function]] | list[Function] | None: # noqa: D102
- return cast(Union[Module, Class, Function], self.target).overloads
+ return cast(Union[Module, Class, Function], self.final_target).overloads
 
  @overloads.setter
  def overloads(self, overloads: list[Function] | None) -> None:
- cast(Union[Module, Class, Function], self.target).overloads = overloads
+ cast(Union[Module, Class, Function], self.final_target).overloads = overloads
 
  @property
  def parameters(self) -> Parameters: # noqa: D102
- return cast(Function, self.target).parameters
+ return cast(Function, self.final_target).parameters
 
  @property
  def returns(self) -> str | Expr | None: # noqa: D102
- return cast(Function, self.target).returns
+ return cast(Function, self.final_target).returns
 
  @returns.setter
  def returns(self, returns: str | Expr | None) -> None:
- cast(Function, self.target).returns = returns
+ cast(Function, self.final_target).returns = returns
 
  @property
  def setter(self) -> Function | None: # noqa: D102
- return cast(Function, self.target).setter
+ return cast(Function, self.final_target).setter
 
  @property
  def deleter(self) -> Function | None: # noqa: D102
- return cast(Function, self.target).deleter
+ return cast(Function, self.final_target).deleter
 
  @property
  def value(self) -> str | Expr | None: # noqa: D102
- return cast(Attribute, self.target).value
+ return cast(Attribute, self.final_target).value
 
  @property
  def annotation(self) -> str | Expr | None: # noqa: D102
- return cast(Attribute, self.target).annotation
+ return cast(Attribute, self.final_target).annotation
 
  @annotation.setter
  def annotation(self, annotation: str | Expr | None) -> None:
- cast(Attribute, self.target).annotation = annotation
+ cast(Attribute, self.final_target).annotation = annotation
 
  @property
  def resolved_bases(self) -> list[Object]: # noqa: D102