Why does the using directive not "associate" with ordinary functions?

According to this question it is valid to define class methods after a using directive, instead of enclosing them within a namespace block.

However, that seems not to be the case for ordinary functions. Consider:

Greeting.hh

#pragma once

namespace NS
{
    class Greeting
    {
    public:
        void hello();
    };

    void otherHello();
}

Greeting.cc

#include "Greeting.hh"
#include <iostream>

using namespace NS;

void Greeting::hello()
{
    std::cout << "Greeting::hello" << std::endl;
}

void otherHello()
{
    std::cout << "otherHello" << std::endl;
}

main.cc

#include "Greeting.hh"

int main()
{
    NS::Greeting o;
    o.hello();
    NS::otherHello();
}

This won't compile, yielding the following error message:

undefined reference to `NS::otherHello()'

Further inspection indicates that otherHello's symbol is not preceded by the namespace, while Greeting::hello's is:

g++ -std=c++14 -pedantic -Wall -c Greeting.cc
nm -C Greeting.o | grep T
000000000000002a T otherHello()
0000000000000000 T NS::Greeting::hello()

Does this contradict with the Standard reference from the accepted answer?

"During unqualified name lookup (3.4.1), the names appear as if they were declared in the nearest enclosing namespace which contains both the using-directive and the nominated namespace."