Двойная диспетчеризация без знания полной иерархии

Я хотел бы реализовать следующую вещь на С++:

Я хотел бы иметь кучу дочерних классов одного класса с возможностью вызова функции, которая принимает пару объектов любого из этих типов. Предполагается наличие универсальной реализации, которая вызывается для смешанных типов или базового типа и специализированных реализаций, которые вызываются, если два объекта одного и того же производного типа используются в качестве аргументов.

Насколько мне известно, это классическое применение двойной отправки. Однако у меня есть следующее ограничение:

Должна быть возможность создавать новые классы из существующих и добавлять новые парные функции для этих новых классов без изменения существующих классов, например, во внешней библиотеке.

Подход, который я предложил в моем последнем вопросе, ошибочен, и предложенное там решение работает только для типов, известных на момент написания базового класса.

Любое предложение о том, как это реализовать? Это вообще возможно?

Обновление: в коде больше тысячи слов. Работает следующий подход:

#include <iostream>

class B;

class A
{
public:
  virtual void PostCompose(A* other)
    {
      other->PreCompose(this);
    }
  virtual void PreCompose(A* other)
    {
      std::cout << "Precomposing with an A object" << std::endl;
    }
  virtual void PreCompose(B* other);
};

class B : public A
{
public:
  using A::PreCompose;
  virtual void PostCompose(A* other)
    {
      other->PreCompose(this);
    }
  virtual void PostCompose(B* other)
    {
      other->PreCompose(this);
    }
  virtual void PreCompose(B* other)
    {
      std::cout << "Precomposing with a B object" << std::endl;
    }
};

void A::PreCompose(B* other)
  {
    PreCompose((A*)other);
  }

int main()
{
  B b;
  A* p = &b;
  p->PostCompose(p); // -> "Precomposing with a B object"
}

но при реализации A требуется знание B. Есть ли способ лучше?