How to Design Programs is a truly fantastic text. Should you choose to read it, I suspect you will be able to learn many useful things from it. However, I hesitate to recommend it as an answer to your question as-stated for two reasons:
HtDP is ultimately a textbook, and it is not written to be read front to back. Rather, it is primarily intended to be used alongside a course taught by an instructor who knows how to use it most appropriately.
More bluntly, HtDP is simply not a book about Lisp.
Yes, HtDP uses a programming language (or, more accurately, a family of programming languages) that happens to be a Lisp. But this is somewhat incidental, and the book can be adapted to other languages (and sometimes is in practice). Moreover, the language used by HtDP is not Racket, nor is it even Scheme—instead, HtDP uses a family of languages specifically designed for teaching, which intentionally lack many of the features that are traditionally considered the qualities that make Lisps interesting.
So what is HtDP about? True to its name, it is a book about how to design programs. It is not about how to design Lisp programs, and although it certainly does have a somewhat functional bent, its ideas are applicable to all programming languages. This is why it is often used as an introductory text. The Lisp is not the point, so if you want to learn about Lisp, HtDP is not going to leave you terribly satisfied.
Given the above, it may sound like I am strongly recommending that you read Structure and Interpretation of Computer Programs, instead, and that is not entirely untrue. Unlike HtDP, SICP is not an introductory text (as much as people sometimes seem to pretend otherwise), but it’s also not really about Lisp, either. Rather, SICP covers some of the foundational ideas in the field of programming languages, and it explores these via simple interpreters written in Scheme. Many of the ideas in SICP are definitely “Lispy” in some sense, and you say you’re interested in perhaps pursuing the field of programming languages, in which case I suspect you will find SICP quite edifying. On the other hand, I personally think many of its ideas are presented better elsewhere (though many would disagree, so YMMV).
Ultimately, the question comes down to what you really want to learn about. Here are a few possibilities:
If you want to learn about writing programs in Lisp or about functional programming more generally, I recommend reading The Racket Guide. The Racket Guide does not exactly present itself as a book, but it is structured like one, and it provides a very thorough introduction to programming in a full-featured Lisp that covers everything from the bare basics to compile-time metaprogramming to higher-order contracts. The Racket Guide is a wonderful resource that will give you everything you need to start writing real Lisp programs (and then some).
If you want to explore the foundations of programming languages using a Lisp as a vehicle, then I recommend Programming Languages: Application and Interpretation by Shriram Krishnamurthi. PLAI covers much of the same content as SICP, but it does so in a more precise and less handwavy way, and it also covers more topics, such as garbage collection.
If you want to learn specifically how to implement a simple Lisp, then I actually think it’s quite possibly more illustrative to do that in a language that isn’t a Lisp. Write You A Scheme uses Haskell as its implementation language of choice, which I think provides a particularly lucid grounding for the ideas it introduces.
Ultimately, all of the things I’ve mentioned here—including both HtDP and SICP—are good reading, so I wouldn’t worry too much about which one you pick. It would certainly be counterproductive to feel overwhelmed by choice and not end up reading any of them, so don’t get stuck in analysis paralysis. But personally, based on the contents of your question, I think The Racket Guide and PLAI would both be great choices to help you get started on your journey into Lisp and programming languages.
(Disclaimer: I am a regular contributor to Racket and am currently employed working on GHC, the Haskell compiler. I like to think my suggestions are relatively unbiased in spite of my personal interests, but then, we all do. :))