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/sem_ir/dump.cpp

@@ -460,6 +460,9 @@ LLVM_DUMP_METHOD auto Dump(const File& file, const NameScope& name_scope)
         case AccessKind::Private:
           out << "private ";
           break;
+        case AccessKind::Hidden:
+          out << "hidden ";
+          break;
       }
       out << DumpInstSummary(file, entry.result.target_inst_id());
     } else {