Editorial meeting: What if there are nested namespaces? What if this is ambiguous (different namespaces)?
Simply say "Unqualified names don't perform ADL".
Don't say anything in the filesystem section.

I have rebased the patch, but it does not yet implement the "editorial meeting" outcome. This patch is currently not ready to be merged.

I would like to make sure that LWG has a chance to look at this and comment on it before it's applied.

We appear to have quite a few places that fail to satisfy this "unless otherwise specified" rule (these are pre-existing errors, but still):

[optional.swap]'s Table 43 says "calls swap(*(*this), *rhs) without saying that ADL is performed
[variant.swap]/2.2 likewise says 'calls swap(...)' without saying that ADL is performed, and similarly in /3 and /4
[queue.defn]'s inline definition of std::queue<T>::swap is:

void swap(queue& q) noexcept(is_nothrow_swappable_v<Container>)
  { using std::swap; swap(c, q.c); }

... which is wrong, and likewise for [priqueue.overview] and [stack.defn].
[alg.swap]/2 likewise says swap(*(first1 + n), *(first2 + n)), and [alg.swap]/6 says swap(*a, *b) with no invocation of ADL.

[container.node.modifiers] likewise uses swap without a "use ADL" proviso, but I think that one is actually correct: we don't want user code interfering with node_handle swaps, but user types can absolutely be associated classes of that lookup

The definition of is_swappable_with deals with this by saying "in an overload-resolution context for swappable values (15.5.3.2)", and looks like the only place we get this right other than the definition of the "swappable" requirements and Swappable concepts.

All this makes me think that perhaps we should move the "swap is found by ADL" rule into the front matter: "Unless otherwise specified, argument-dependent name lookup is only performed within the standard library for operator-function-ids and for the identifier swap." -- and we should change [container.node.modifiers] to explicitly specify that ADL is not performed. Though in the short term, we could instead update the places listed above to say "in an overload-resolution context for swappable values".

Rebased,

I've added the front-matter talk about "swap", which results in fewer changes than talking about ADL everywhere "swap" appears.

@jwakely, could you have LWG look at this?

Editorial 2021-04-30: Remove iostreams.tex changes; they are covered by LWG2818.
The lib-intro.tex change needs to wait for LWG2818 to land.

The only residual open issue is the special treatment of swap. See the updated diff.

@jwakely, this adds special treatment for swap to avoid extra words everywhere. Please have a look.

@tkoeppe, this looks ready now.

See also LWG 3629: make_error_code and make_error_condition are customization points.

when the paper standard says swap_ranges, the implementor should write std::swap_ranges in the code

This is not accurate:

namespace N {
  namespace std {
    void f();
  }
}

using namespace N;

namespace std {
  void f();
  void g() { std::f(); }
}

x.cc: In function ‘void std::g()’:
x.cc:12:14: error: reference to ‘std’ is ambiguous
   12 |   void g() { std::f(); }
      |              ^~~
x.cc:3:13: note: candidates are: ‘namespace N::std { }’
    3 |   namespace std {
      |             ^~~
<built-in>: note:                 ‘namespace std { }’

So, the implementer needs to use ::std::function_name() to disambiguate properly.
(If the function is not overloaded or a template, you might also get away with something like (+f)() (convert to a function pointer first, which doesn't use ADL).)