perf: pre-declare position on link/text factories

Problem: this extension builds link nodes (and their nested text
children) in two paths: the enter handler for literal autolinks
during parse, and a post-parse find-and-replace transform that walks
text nodes and produces link/text nodes from URL-shaped substrings.
In both paths the literals are fresh objects with no position field;
position is patched in afterwards. V8 treats the late assignment as
a shape change, so every link and text node walks through two hidden
classes instead of one. Core nodes already avoid this; extension
nodes leave the tree with mixed layouts and tree walks lose
monomorphic dispatch.

Goal: declare position on every link and text literal this extension
produces, both in the enter handler and in the post-parse transform,
so V8 keeps a single hidden class per node type.

Changes:
- lib/index.js: trailing position: undefined on the link literal in
  enterLiteralAutolink.
- lib/index.js: trailing position: undefined on the link and nested
  text literals returned from findUrl, plus the trailing-text node
  when splitUrl strips punctuation.
- lib/index.js: trailing position: undefined on the link and nested
  text literals returned from findEmail.

Notes: the transform-path literals at lines 175 through 180, 183, and
207 through 212 are returned from find-and-replace callbacks rather
than going through this.enter(). A one-off probe (parsing
'visit www.example.com\n' with the GFM extension) confirmed that
something further down the pipeline populates position on these
nodes, so the pre-declared field gets overwritten with a real value
and the test fixtures continue to assert real position objects.
Pairs with the matching core change in
syntax-tree/mdast-util-from-markdown#53;
merged on its own this branch is a no-op. Validated with npm test
(build, format, 100% coverage, 49 of 49 tests in dev and prod).

Bench (local harness, 3-run median-of-medians, GFM tokenizer and
mdast extensions stacked, with the core branch and three sibling
extension branches checked out alongside this one):

Two scenarios exercise this code path. The first is 5000 bare URLs
interleaved with surrounding text, which is the largest mdast-layer
share in the GFM corpus on the baseline (full 319.6 ms, tokenize-only
142.8 ms; the gap between those is roughly 35 microseconds of
mdast-layer work per URL, mostly node allocation and position
bookkeeping). The second is the syntax-tree GFM-stack readme used as
a real-world fixture, where the autolink resolver still walks every
text node.

  scenario                       baseline   core alone   core + paired
  5000 bare URLs + text          319.6 ms   +2.3%        -2.5%
  syntax-tree GFM-stack readme   22.8 ms    +29.4%       +22.5%

The bare-URL scenario is the only paired-vs-baseline comparison
across the whole 5-repo paired set that crosses zero (i.e., the
paired configuration parses faster than upstream main does). The
4.8-point swing from solo to paired matches what the V8 hidden-class
hypothesis predicts: with link and text literals sharing the core
layout, every link in the resulting tree dispatches through one
inline cache.

A drift floor measured separately ran at +4 to +12 percent across
most GFM inputs on this machine in the same window; the readme's
+22.5 percent paired residual is in the upper end of that band, which
is consistent with no real regression.

Author: ChristianMurphy

lib/index.js

@@ -80,7 +80,13 @@ export function gfmAutolinkLiteralToMarkdown() {
  * @type {FromMarkdownHandle}
  */
 function enterLiteralAutolink(token) {
-  this.enter({type: 'link', title: null, url: '', children: []}, token)
+  // Trailing `position: undefined` keeps the link hidden class stable;
+  // mdast-util-from-markdown's enter() patches the field to a real value
+  // but the property already exists, so no shape transition fires.
+  this.enter(
+    {type: 'link', title: null, url: '', children: [], position: undefined},
+    token
+  )
 }
 
 /**
@@ -171,16 +177,20 @@ function findUrl(_, protocol, domain, path, match) {
 
   if (!parts[0]) return false
 
+  // Trailing `position: undefined` on every node literal keeps each
+  // link / text hidden class stable; an upstream pass in find-and-replace
+  // patches the field to a real value before the node is observable.
   /** @type {Link} */
   const result = {
     type: 'link',
     title: null,
     url: prefix + protocol + parts[0],
-    children: [{type: 'text', value: protocol + parts[0]}]
+    children: [{type: 'text', value: protocol + parts[0], position: undefined}],
+    position: undefined
   }
 
   if (parts[1]) {
-    return [result, {type: 'text', value: parts[1]}]
+    return [result, {type: 'text', value: parts[1], position: undefined}]
   }
 
   return result
@@ -204,11 +214,13 @@ function findEmail(_, atext, label, match) {
     return false
   }
 
+  // See findUrl above for the rationale on the trailing position field.
   return {
     type: 'link',
     title: null,
     url: 'mailto:' + atext + '@' + label,
-    children: [{type: 'text', value: atext + '@' + label}]
+    children: [{type: 'text', value: atext + '@' + label, position: undefined}],
+    position: undefined
   }
 }