The key feature of explicit parse trees (or, probably more accurately, abstract syntax trees) that makes them useful is that they are as close as it's possible to get the source program, while still following the structure of the source program. This makes them ideal for implementing any programming language feature which is better expressed in terms of the source language.
Perhaps the most obvious example is semantic analysis. Many modern programming languages have semantics which require reading in the whole program first (e.g. languages which don't require forward declarations). Any semantic error (e.g. a type error) should be reported to the user in a way that refers to the source program as closely as possible, so using an abstract syntax tree makes more sense than an intermediate representation.
(As an aside, generating high-quality diagnostic/error messages is an under-appreciated aspect of compiler development. These messages are, in a sense, the primary user interface of a compiler as far as a programmer is concerned.)
Another example is applying optimisations or transformations which are defined in terms of the source language, such as copy elision in C++. For retargetable compilers or compiler frameworks (e.g. GCC, LLVM), these transformations are neither source-language-independent, nor target-architecture-dependent, so implementing them on the ASTs prior to IR generation is usally the best option.