Support signature mismatch between virtual fn and override fn. (#7198)

For now, hide `override fn`s from name lookup, so that the base class
version is always used, as the derived-class version does not have its
own vptr entry and so would not do the right thing if a further-derived
class adds a new override. This is implemented via a new access kind of
`Hidden`.

When checking the overriding function, pass in the expected `Self` type
and check the `self` parameter against that; the signature that we
generate for the thunk in the derived class is the base class signature
with the `self` parameter's type changed to the derived class.

When we generate a thunk for a virtual function, the thunk is assigned a
`virtual_index`, and the virtual function itself is not. When the thunk
makes a direct call to the virtual function, recognize this situation by
checking for a `virtual_index`, and perform a non-virtual call if there
isn't one.

Assisted-by: Gemini via Antigravity

toolchain/check/cpp/access.cpp

@@ -51,6 +51,7 @@ auto MapToCppAccess(SemIR::AccessKind access) -> clang::AccessSpecifier {
     case SemIR::AccessKind::Protected:
       return clang::AS_protected;
     case SemIR::AccessKind::Private:
+    case SemIR::AccessKind::Hidden:
       return clang::AS_private;
   }
 }