Is "sparse subtree" an appropriate term for what I describe in this question?
2021 update: &quot;embedded subtree&quot;
In a discussion elsewhere8, I just encountered a term of interest with its own Wikipedia page: induced subgraph. This was roughly the sort of term I was after when I asked my original question, though it doesn't nail it.
It led me to google for &quot;induced subtree&quot;. That has 80 matches and looked more appropriate for what I was after. But it still wasn't right because it disallows ancestor-descendant pairings that aren't parent-child.
That led me to &quot;embedded subtree&quot; in this paper which notes:

[In contrast to &quot;induced subtrees&quot;] Embedded subtrees ... allow not only direct parent-child edges, but also ancestor-descendant edges.

So maybe that's the right term.
On the other hand it still doesn't cover what I'm calling &quot;annotation&quot; -- the key notion that the nodes in the &quot;subtree&quot; are paired up with a subset of nodes in the original tree but are not actually the same nodes.
So due to that technical aspect, and for aesthetic reasons, I currently feel my original answer, which follows, remains as acceptable as it ever was. ;)
AST
This self answer defines the terms and acronyms I've made up to refer to what I asked about.1
The terms I've made up are general definitions of two kinds of tree data structure. I define them more precisely in later sections but in summary they are:

A Sparse Tree aka AST. A sparse subset of a tree.

Annotated Subset Tree aka AST. A sparse tree formed via &quot;annotation&quot;.


Why define terms to distinguish the concepts when their acronyms eliminate the distinction? Because the mental modelling utility of eliminating the distinction is what I wanted to emphasize first and foremost, while still defining the distinction to make it clear what's going on behind the scenes.
AST typically refers to Abstract Syntax Tree
One existing typical meaning of AST in the CS world is the specific context I had in mind when I posed my question.2
So now we have not two but three ASTs. In the section Why three ASTs?!? below I'll return to why I'm defining three distinct tree concepts that all share the same acronym.
A Sparse Tree
By A Sparse Tree3 I mean a node of a tree data structure that serves as a root, plus any &quot;well formed&quot;4 potentially sparse subset tree formed of branch and leaf nodes relative to that root.
My example will be A Sparse Tree formed from a parse tree.5
If source code is like this:
foo = bar # Assign bar to identifier foo

And the parse tree is like this:
TOP
  statement                   foo = bar # Assign bar to identifier foo
    assignment                foo = bar
      identifier              foo
      assignment operator     =
      identifier              bar
    end-of-line-comment       # Assign bar to identifier foo

then the following represents two of many possible sparse trees based on that single parse tree:
# A Sparse Tree:
    assignment                foo = bar
      identifier              foo
      identifier              bar

# Another Sparse Tree:
    end-of-line-comment       # Assign bar to identifier foo

Annotated Subset Tree
By Annotated Subset Tree6 I mean A Sparse Tree represented/stored by annotating a subset of the nodes of a tree.
By &quot;annotating&quot; I mean hanging an additional node of data off selected nodes.
Why three ASTs?!?
One abstract use case for sparse trees is forming an Abstract Syntax Tree that consists of annotations of the Parse Tree generated by a parser.
When the distinction between A Sparse Tree, an Annotated Subset Tree, and an Abstract Syntax Tree is moot -- which is most of the time -- just use the acronym AST without worrying about the ambiguity, because, by my definitions, it doesn't matter.7
That's why the terms I've coined share the same acronym: AST -- so they can be understood as theoretically distinct things but, for some parser implementations, the same thing in practice.
Footnotes
1 My question was originally an attempt to find out if there was already an accepted term for what I described, generically in regard to trees, without regard for Abstract Syntax Trees. Then it became documentation of that attempt and the CS exchange community's response:

I'm not sure there is a standard term. Feel free to make up your own.
Just be sure to explain at least once in some detail what the term means.

2 I deliberately didn't state this context for my question because my original goal was to find out if there was a generic CS term about such trees.
3 A google for &quot;sparse tree&quot; suggests a few things, most notably a new christmas tree aesthetic and an aspect of a software feature (Emacs Org mode), as well as some genuinely CSish notions, but I didn't find any matching what I've described in this answer.
4 By &quot;well formed&quot; I mean that each node in the sparse/subset tree contains content from, and/or pointers to, the content of other nodes along branches proceeding in the direction of the tree's leaves from the sparse/subset tree's root node.
5 The word &quot;sparse&quot; is onomatopoeically reminiscent of &quot;parse&quot;. This is a &quot;happy mnemonic accident&quot; given that the context for me naming these things is a sparse tree formed from a parse tree. It also reminds me of &quot;A partridge in a pear tree&quot; and I have fantasized that I will one day come up with and publish a worthy pun along those lines.
6 A google for &quot;annotated subset tree&quot; suggests a variety of CSish notions, but I didn't find any matching what I've described in this answer.
7 Of course, the usual use of the term &quot;AST&quot; in a CS context is an Abstract Syntax Tree. The whole point of this SO was to pick abstract terms describing a concrete approach that may be taken by parsers storing an AST. The fact that the terms all initialize to AST, with Abstract Syntax Tree being the dominant meaning of that acronym, is, of course, deliberate, and, imo, delightful.
8 A reddit.com/r/ProgrammingLanguages discussion