Is Lisp not so popular in implementing other (not functional) programming languages? Do you know of some good documentation about implementing a compiler in LISP?
I think there are few examples because of lack of motivation.
Normally when you implement a compiler or an interpreter the point is raising the level of abstraction. It makes a lot of sense to implement an assembler writing in machine code, then a C compiler using the assembler, then a Python interpreter using the C compiler...
Staying on the same level or going in the opposite direction is not nonsense but a lot less natural... and is done mainly for portability. Some cases are implementing an assembler (for a different processor or for a generic processor) using an higher level language, bootstrapping a compiler, implementing a virtual machine.
With Lisp the whole idea of language level doesn't fit that well (here I mean a full Lisp that includes general full macros, reader macros and that is not allergic to side effects, not a self limited version that only allows template based macros or forces you to a functional programming model).
Lisp is neither an high level language, nor a low level one... more than a language Lisp is a meta-language in which you shape the language that would be ideal to solve the problem you are facing. Creating language abstraction levels is just normal programming in Lisp and doesn't require a new language, compiler or interpreter.
In Lisp you don't need to implement a whole different language if you need a specific abstraction (e.g. exceptions, objects), you just implement that abstraction for use within Lisp. There have been systems programmed down from hardware control up to artificial intelligence all in Lisp.
For example in Common Lisp there is support for object oriented programming (and more sophisticated than in C++) but if it wasn't there it could be just coded... and indeed it was a regular library before Common Lisp. In C instead the only way was to create a full compiler from C++ to C to be able to get there.
Common Lisp Macros are compilers. If you write a macro that transforms some code into Common Lisp that can then be compiled by Common Lisp, then isn't that a compiler? Check out some Common Lisp programming books on Macros, and I think you'll find some very useful information there. I'd recommend On Lisp and Let Over Lambda.
A recent practical example of using Common Lisp macros as a code transformer/compiler is CLPython, but there are all sorts of DSLs/other examples that use this technique.
Another good example is Doug Hoyte's implementation of a Forth compiler in Common Lisp; that one is at the end of Let Over Lambda.
I assume by books about "implementing SCHEME/LISP in LISP" you mean such titles, as Lisp in Small Pieces.
Regarding the former approach, it's actually no different from other languages, so you can start with the Dragon Book and apply the same technics. Regarding the latter approach, it has some syntactic limitations, but it also has two advantages: using Lisp's built-in configurable lexer and parser, and the ability to tap into Lisp itself and use its facilities alongside the language you're implementing. It is called DSL-oriented programming, and some of the best books about it were mentioned in the previous answers: On Lisp and Let Over Lambda.
Lisp compilers are pretty conventional, except that the syntax phase is a lot simpler. It's the data structures in lisp that are unusual compared to other languages. Lisp targets a virtual machine with a specific set of properties (different depending on the variant). Google "lisp virtual machine"
Lisp programmers use the language to solve tasks other than writing a Lisp compiler in itself.
Most Common Lisp implementations (I cannot think of an exception at the moment) are compiled, and their compilers are written in Lisp. The code is there, just maybe not the papers and tutorials.