I think there are people with more and less strict definitions of what can be called a Lisp family language. I believe I have seen one person who had a definition such that nothing but Common Lisp was a Lisp, not even Scheme. I don't recall why, probably because their reasons did not make much sense to me.

IMHO, I consider Common Lisp, Scheme, Clojure, Emacs Lisp, Autolisp, and a few others I'm forgetting about now a Lisp. I prefer some over others, but I don't kick them out of my Lisp club because they have features I prefer less.

You put in the effort and develop a game whose screenshot looks like this:

  You see here a silver ring.
                                            ------------
                                          ##....._.....|
                                            |...........#          ------
                                           #...........|           |....|
                       ---------------   ###------------           |...(|
                       |..%...........|##########               ###-@...|
                       |...%...........###    #                 ## |....|
                       +.......<......|       ###              ### |..!.|
                       ---------------          #              #   ------
                                                ###          ###
                                                  #          #
                                               ---.-----   ###
                                               |.......|   #
                                               |........####
                                               |.......|
                                               |.......|
                                               ---------
  Hacker the Conjurer            St:11 Dx:13 Co:12 In:11 Wi:18 Ch:11  Neutral
  Dlvl:3  $:120 HP:39(41) Pw:36(36) AC:6  Exp:5 T:1073

and people say that it's "Rogue-like" or "a Roguelike", not "Rogue".

Somehow, nobody is upset about this.

But if you make some shitty evaluator with nested parentheses and throw it into Github, woe to him who dares say it's only "Lisp-like".

Think about it.

"Dung Beetles isn't a Pac Man??? Why, you obnoxious, gatekeeping poo-poo head!"

Of those I would consider Common Lisp, Emacs Lisp and Autolisp as Lisp dialects. They also seem to signal that in their name. The other languages are new, derived and possibly closely related to Lisp. Other languages in that category: LOGO, ML, Dylan, JavaScript, Julia, R, ... That's a larger Lisp family of related, but not compatible languages. Many of these languages were developed to improve Lisp: the syntax, functional programming, execution speed for numerics, simplified, mass market appeal, less dynamic, more dynamic, static typing, ...

"The other languages are new, derived and possibly closely related to Lisp." Scheme's first specification was in the 1970s some time [1]. From the perspective of 2022, that is not much younger than the original Lisp.

[1] https://en.wikipedia.org/wiki/Scheme_(programming_language)

Lisp was then already 17 years old. 1958 -> 1975. Compared to Lisp, Scheme was new and it was developed after significant experience with the original Lisp's scoping problems. A bunch of other and different programming language were developed at that time. For example ML was also written in Lisp originally, sharing some of its design (like support for functional programming with linked lists).

Scheme was originally implemented on top of Maclisp. It shared its infrastructure and a lot of design: from linked lists, the list-based syntax, ... onwards. A bunch of research papers about it were published. Later it was then described by a series of language reports RNRS (parallel to the further evolution of Lisp), was also standardized as a programming language (the IEEE Scheme standard) and a series of documents describing language extensions (SRFI). In the earlier history the RNRS reports were kept minimal to enable the use of Scheme in the context of education, R6RS then was much larger.

1178-1990 - IEEE Standard for the Scheme Programming Language https://ieeexplore.ieee.org/document/159138

Scheme was not a minimally improved Maclisp, but a new language with significant Lisp influence. There was a lot of sharing over the years between Lisp and Scheme, but Scheme got its own books, its own implementations (many), its own libraries, its own community, ... Programming language are social groups, too and Scheme formed one early on. As a programming language design it was very successful and influential.

Note that I'm not saying that one is better than the other (though Scheme was improving Lisp in important ways by solving problems like scoping in functional programs and later a lot of language research was done in the context of Scheme), just that different communities with different goals were formed. Scheme was the well-designed, small and theoretically ground language. Lisp was the more messy big ball of mud, having lots of historical baggage, with its language design dating back to the original Lisp 1.

Yet, consider that if you say "Modula-2 isn't Pascal", you will hardly get an eyebrow to raise.