This patch reimplements ADL.

I replace the existing adl_lookup object with a new name_lookup object, 
and move all the workers into it as member fns.

In terms of implementation, ADL requires us to look in a bunch of 
places, and we obviously want to look in each place only once.  The 
current implementation uses a vector, which it scans to see if we've met 
the class or namespace before.  Not even a hash table!

Anyway, this implementation introduces LOOKUP_SEEN_P and LOOKUP_FOUND_P 
to directly mark the DECL node.  Hence determination is now O(1) rather 
than O(N^2).  We still have a vector to recall which decls we need to 
unmark at the end of the lookup.  We need two markers on a class, 
because depending on how we found it we may need to search additional 
things about it. (These two maker bits will be used in later changes too.)

One quirk is that ADL can be recursive.  ADL can cause template 
instantiation, which can in turn cause a different ADL to happen.  The 
new testcase is an example of this.  So, we need to detect this and 
undo/redo the outer DECL marking during the inner ADL.  Thus 
implementing a simple chain of ADLs and using their record of which 
decls got marked to undo/redo.  The fiddly bit there is recording 
whether LOOKUP_FOUND_P was set or not (LOOKUP_SEEN_P will be).  To 
record that I simply push those DECLS with lookup_found_p set onto the 
stack.  They'll thus appear twice, and we can infer from the second 
sighting that it had FOUND_P set (and pop the stack).  The recursion is 
a rare event, so we optimize the non-recursive case.

I use a static vec for the scopes of outermost lookup object.  That'll 
avoid malloc/free for every lookup in the usual case.  Inner lookups get 
their own stack (but as mentioned are rare).

I still keep the old code's determination of whether a found fn was in 
the original lookup or not.  That will go away soon.  As will the 
iteration over inline namespaces.

nathan
-- 
Nathan Sidwell