It is not clear from your question where you found that quotation, or in what context it is being used. However, "async all the way down" is generally understood to mean that you shouldn't switch back and forth between synchronous and asynchronous methods in a single logical operation.
If something is to be done asynchronously, it should be consistently asynchronous, at all levels—thus, "all the way down" (and up) the hierarchy/call stack/etc. In other words, it never makes sense to do a synchronous, blocking call at any point in asynchronous code, because then it isn't really asynchronous at all.
From the .NET Parallel Programming team's blog entry, "Should I expose synchronous wrappers for asynchronous methods?":
Async All the Way Down
The point here is that you need to be extremely careful when wrapping asynchronous APIs as synchronous ones, as if you’re not careful, you could run into real problems. If you ever find yourself thinking you need to call an asynchronous method from something that’s expecting a synchronous invocation (e.g. you’re implementing an interface which has a synchronous method on it, but in order to implement that interface you need to use functionality that’s only exposed asynchronously), first make sure it’s truly, truly necessary; while it may seem more expedient to wrap “sync over async” rather than to re-plumb this or that code path to be asynchronous from top to bottom, the refactoring is often the better long-term solution if it’s possible.
As for your question about where can this be found in the .NET source code, MSalters has already answered this. Fundamentally, the .NET APIs will call down to system-level APIs provided by the Windows operating system. These perform asynchronous I/O, and signal the caller when they have completed. You don't really need to understand how this works on a technical level, though; that is the whole point of the abstraction.