visibility of template functions during subsitution and std::tuple

The following code compiles in clang but not gcc or msvc. It appears that when gcc or msvc fails, it is because the forward declaration don't cause all of the definitions of foo to be visible while evaluating `decltype`. Clang evaluates the `decltype` after the forward declarations. Given that gcc fails with `std::tuple` but not a custom type suggests that maybe gcc has a bug, but I don't want to report the bug to multiple projects until someone more knowledgeable of the spec confirms what the behaviour is supposed to be.

https://godbolt.org/z/e5oG6Gcn9
```c++
#include

//declare the templates
constexpr int foo(int a);

template class T, class Td>
constexpr T()))>
foo(T a);

//----- then define them
constexpr int foo(int a);

template class T, class Td>
constexpr T()))>
foo(T a){return {};};

template struct A {};
template struct my_tuple{};

int main() {
foo(A>{}); //this works in gcc for some reason (msvc fails)
foo(A>{}); //this fails in gcc
return 0;
}
```

Start with the minimized example in the issue and reproduce it using the linked Compiler Explorer case. Compare clang, GCC, and MSVC results for the std::tuple and my_tuple calls, then consult the relevant C++ rules for template substitution, forward declarations, and decltype. Done means establishing the expected behavior and documenting whether an LLVM change or a report to another compiler is appropriate.

Written by the indexing model from the issue text.