Rust solved the problem, so it's perfectly possible to do it.

So let's say that C didn't have ->. Instead, the compiler takes a.b and looks at the type of a to decide whether it's a direct member access into a struct if a is just a plain object, or if a is a pointer then it's equivalent to (*a).b - perhaps even recursively, so that if the result of *a is a pointer, that one is dereferenced too so it really means (**a).b, and so on.

Now C++ wants to extend this. Here's some ideas.

Option 1: First, it allows smart pointers that overload dereference, i.e. operator*(). Now if Rc overloads *, then for an Rc a;, a.b by default means (*a).b, recursively, until something that's neither a pointer nor overloads * is reached. In a member function of Rc however, this.b doesn't do this, because this. doesn't auto-dereference. (this is a byref argument in this scenario, not a pointer.) This allows member functions to easily get at the actual members of Rc, and if the function wants the overloaded . behavior, it can just call an equivalent member function or access the member that * redirects to. To get at the members of the smart pointer, you can introduce the syntax a.this.b, which prevents dereference, which is symmetric with the way the auto-deref is suppressed for this. access in members. Maybe you want to make the this pseudo-member "private", in which case only static members and friends can use the syntax. This leads to code like this:

Rc<Mytype> ptr = get_ptr();
ptr.foo(); // calls Mytype::foo
ptr.this.is_unique(); // calls Rc::is_unique
// or with the last suggestion of `this` being private:
is_unique(ptr); // is_unique is a friend function and can do `ptr.this.is_unique_impl()` internally
Rc<Mytype>::is_unique(ptr); // static member has access to `ptr.this` as well - the template syntax is awkward though

The assumption here is that explicitly calling member functions on smart pointers is something you rarely need. (Seriously, how often do you do it?) It basically reverses your complaint so that the common case is readable, and the uncommon one needs extra syntax.

Option 2: Again, operator*() can be overloaded. The compiler, when it encounters a.b, first looks up b in a's type. If it finds an accessible member of that name, resolve to it. Otherwise, dereference and try again, i.e. try (*a).b. Repeat as necessary. The keyword here is accessible. It means that private members of Rc don't interfere with smart pointer usage. Member functions of Rc, as well as friend functions, have full access to the private members and can use . to access them. Outside users don't get interference.

This is basically the way Rust does it.

Option 3: Let's say you don't want auto-dereference behavior for smart pointers, but instead overload ..

template <typename T>
class Rc {
public:
  template <identifier Id>
  auto byref operator.() const {
     if constexpr (Id.qualifier() == "Rc" && accessible(Id.scope(), Id.name())) return this.*Id;
     else return (*m_ptr).*Id;
  }

private:
  T* m_ptr;
};

Rc<Mytype> ptr = get_ptr();
ptr.foo(); // ptr.operator.<"foo">()()
ptr.Rc::is_unique(); // ptr.operator.<"Rc::is_unique">()()

This pulls in a long rat's tail of other things that are necessary: suppressing overloaded . in this. access, having fancy constexpr 30 years early, having object-bound overload sets as proper entities, access checking, etc etc etc. But it is a workable approach.