Почему std::find не использует мой operator==?

Ответ по ссылке, с которой был сделан перевод, неверен/неточен. ADL-поиск никак не заменяет/не исключает обычный поиск, а лишь дополняет его.

Правильное описание ситуации заключается в следующем:

1. Обычный поиск выполняется из места вызова оператора == из определения шаблона функции std::find в стандартной библиотеке. Он находит только те имена, которые видны из этого места.

   Понятно, что оттуда приведенное определение оператора == не видно.

2. ADL-поиск выполняется в ассоциированных и только в ассоциированных пространствах имен и видит эти пространства имен такими, каким они стали на момент вызова функции std::find в вызывающем коде. Набор ассоциированных пространств имен строится в соответствии с правилами, описанными 6.4.2/2.

   В данном случае из точки вызова std::find приведенное определение оператора == прекрасно видно. Но это определение сделано в глобальном пространстве имен. А ассоциированным для ADL в данном случае является только пространство std, ибо оба аргумента сравнения принадлежат пространству std. Поэтому глобальное пространство имен не рассматривается ADL и данное определение не находится.

   Утверждение о том, что ADL якобы прекращает дальнейший поиск определений operator == именно из-за того, что какие-то определения operator == уже найдены внутри std - неверно. ADL всегда ищет имена только внутри ассоциированных пространств имен. В отличие от обычного lookup, ADL никогда не расширяет область поиска за пределы ассоциированных пространств имен, независимо от того, найдено там что-либо или нет.

Ту же проблему можно проиллюстрировать следующим маленьким примером

namespace N
{
  struct S {};
}
template <typename T> void foo(T a) 
{
  bar(a);                         // 1
}
void bar(N::S s) {}
int main()
{
  N::S a;
  foo(a);                         // 2
}

При таком порядке объявлений обычный поиск имен находит имена, видные из точки 1, а ADL поиск находит имена, видные из точки 2, но только в ассоциированных пространствах имен. Глобальное пространство имен ассоциированным не является, поэтому объявление void bar(N::S s) не находится и код не компилируется.

В исходном варианте, если мы каким-то образом "притянем за уши" глобальное пространство имен в качестве ассоциированного для ADL, то данный оператор == сразу начнет находиться через ADL. Например, объявим в глобальном пространстве имен некий фиктивный тип, приводимый к std::string и используем именно его в качестве ключа для поиска

...
struct S : std::string
{
    using std::string::string;
};
int main()
{
    std::vector<RegPair> sequence;
    S foo("foo");
    std::find(sequence.begin(), sequence.end(), foo);
}

Определение оператора сравнения при этом менять не надо. Код сразу начнет компилироваться и использовать данный оператор сравнения.

Другой вариант внешне "невинной" замены, который заставит код компилироваться - сделать второй член пары типом из глобального пространства имен

struct X {};
typedef std::pair<std::string, X> RegPair;

Больше ничего менять не надо - этого уже достаточно для того, чтобы ассоциировать глобальное пространство имен для ADL.

Проблема заключается в том, что std::find является шаблонной функцией, а потому при поиске operator== в дело вступает ADL (поиск, зависимый от типов аргументов).

Оба аргумента функции (std::pair и std::string) находятся в одном и том же пространстве имён (::std), поэтому ADL начинает поиск именно в нём. При этом достаточно, чтобы там был определён хоть какой-то operator==, так как сопоставление имён (name lookup) производится до определения подходящих перегрузок.

В связи с тем, что подходящий по имени operator== обязательно будет найден (в том же<string> объявлен как минимум оператор сравнения std::string с чем-то), алгоритм останавливает свою работу. До вашей же перегрузки, расположенной в глобальном пространстве имён (то есть за пределами ::std), очередь так и не дойдёт.