is this an ADL bug or not?

Compiling the following code:

#include <iostream>
#include <sstream>
#include <tuple>
#include <type_traits>

namespace NS
{
    struct Point
    {
        int x;
        int y;
    };

    template <typename StreamType>
    inline StreamType& operator<<(StreamType& stream, const Point& obj)
    {
        return stream << std::make_tuple(
                                         obj.x,
                                         obj.y);
    }

    struct Serialize
    {
        template <typename ...T>
        struct for_each
        {
            for_each(const std::tuple<T...>& t) : t_(t) { }
            const std::tuple<T...>& t_;

            template <std::size_t pos = 0, typename StreamType>
            StreamType& operator()(StreamType& stream, typename
std::enable_if<(pos >= sizeof...(T))>::type* = nullptr)
            {
                return stream;
            }

            template <std::size_t pos = 0, typename StreamType>
            StreamType& operator()(StreamType& stream, typename
std::enable_if <(pos < sizeof...(T))>::type* = nullptr)
            {
                if (pos) { stream << stream.sep_; }
                stream << std::get<pos>(t_);
                return this->operator()<pos + 1>(stream);
            }
        };

        template <typename ...T>
        Serialize(const std::tuple<T...>& t) :
            sep_(","), quoted_(true) { (*this) << t; }

        template <typename T>
        Serialize(const T& obj, bool autoProviders = true) :
            sep_(autoProviders ? "_" : ", "), quoted_(false) {
NS::operator<<(*this, obj); }

        std::string str() const { return stream_.str(); }

        template <typename ...T>
        Serialize& operator<<(const std::tuple<T...>& t)
        {
            for_each<T...> functor(t);
            return functor(*this);
        }

        template <typename T>
        Serialize& operator<<(const T& t)
        {
            stream_ << t;
            return (*this);
        }

        Serialize& operator<<(const std::string& s)
        {
            if (!quoted_) { stream_ << s; }
            else { stream_ << '\'' << s << '\''; }
            return (*this);
        }

        std::ostringstream stream_;
        const char* sep_;
        bool quoted_;
    };

    template <typename ...T>
    inline std::ostream& operator<<(std::ostream& stream, const
std::tuple<T...>& t)
    {
        return stream << Serialize(t).str();
    }
}

int main()
{
    std::ostringstream os;
    NS::Point p = {1, 2};
    os << p;
    return 0;
}

produces the error:

clang++ --std=c++11 test_operator_adl.cpp
test_operator_adl.cpp:17:17: error: call to function 'operator<<' that is
      neither visible in the template definition nor found by
argument-dependent
      lookup
                return stream << std::make_tuple(
                              ^
test_operator_adl.cpp:92:5: note: in instantiation of function template
      specialization 'NS::operator<<<std::basic_ostringstream<char> >'
requested
      here
        os << p;
           ^
test_operator_adl.cpp:82:23: note: 'operator<<' should be declared prior
to the
      call site
        inline std::ostream& operator<<(std::ostream& stream, const std:...
                             ^
1 error generated.

I would have thought that since all the necessary definitions have been
seen before the spot where the templates are instantiated and operator<<
is used that we have satisfied the requirement that "operator<< should
be declared prior to the call site". Is this a bug or I just don't
understand things correctly?