Fix or alternative to ADL when one of the functions is actually a function object

Question

In the following code, the standalone component in the namespace S has its own definitions of Big and Small types, together with a split function to split one Big into a collection of the Smalls.

S also provides another function, work, which makes use of split, and is meant to be used by S itself and also by other dependent components, e.g. the one in the namespace D, which are assumed to provide their own definitions of Big and Small and their own definition of split, which will be identified via ADL.¹

#include <iostream>
#include <string>
#include <utility>
#include <vector>

namespace S /* standalone */ {
    struct Big{};
    struct Small{};
    std::vector<Small> split(Big b) {
        std::cout << "S" << std::endl;
        return {/* use b to make output */};
    }
    template<typename BigT>
    void work(BigT/* acutally this is a template class with `BigT` as a template paramter*/ x) {
        split(x); // correspondingly `split` is not applied on `x` but on the `BigT` which is part of it
        // a lot of complex stuff
    }
}

namespace D /* dependent on standalone */ {
    struct Big{};
    struct Small{};
    std::vector<Small> split(Big b) {
        std::cout << "D" << std::endl;
        return {/* use b to make output */};
    }
}
int main() {
    S::Big line1{};
    D::Big line2{};
    S::work(line1); // uses S::split
    S::work(line2); // uses D::split
}

Well, in reality S::split is a function object, not a function²,

namespace S {
    struct Split {
        std::vector<Small> operator()(Big) const {
            std::cout << "S" << std::endl;
            return {};
        }
    } split;
}

so ADL doesn't work.

Any suggestion on how to address these needs?

From the comments emerges that maybe Niebloids and/or tag_invoke represent an answer to my question. And I'd really like to understand more about these concepts.

For now, my understanding of Niebloids (and I'm reading this blog from Eric Niebler) is that they are function objects that (when they're in scope) prevent ADL, thus "focusing" all function calls directed to unqualified free functions with the same name as the niebloid; their operator(), however, relies on ADL to forward the call to the appropriate free function. Therefore it looks like the contrast in my example code between S::split being a function object and D::split being a free function cannot be addressed by niebloids, unless I make S::split a free function (in which case ADL would suffice in my simple scenario).

---

¹ Originally work was defined in both S and D, and the code above is my attempted refactoring, during which I run into the described issue.

² The reason for this is that S::split is used in several contexts in S, it has a few overloads of operator(), and most importantly, it's often passed around as an object, which is very handy.