perf: pre-declare position on footnote factories

Problem: the footnote handlers build footnoteReference and
footnoteDefinition nodes as fresh literals, then mdast-util-from-
markdown's enter() sets node.position afterwards. V8 treats that
late assignment as a shape change, so each node walks through two
hidden classes instead of one. Core nodes already avoid this by
declaring position up front; without the same trick on extension
nodes, GFM trees end up with mixed layouts and tree walks pay a
polymorphic-dispatch cost.

Goal: declare position on both footnote literals at construction so
V8 keeps a single hidden class per node type.

Changes:
- lib/index.js: trailing position: undefined on the footnoteReference
  literal in enterFootnoteCall.
- lib/index.js: trailing position: undefined on the footnoteDefinition
  literal in enterFootnoteDefinition.

Notes: 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, 22 of 22 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):

Input: a document with 1000 footnote definitions and 1000 references
to them. On the baseline this scenario carries a modest mdast-layer
share (full 78.0 ms, tokenize-only 62.4 ms) but every footnote node
still pays the shape-change cost without the pre-declare.

  setup                          delta vs main
  core branch alone              +19.5%
  core branch with this paired   +13.0%

The 6.5-point swing tracks the recovery on footnote nodes. A drift
floor measured separately ran at +4 to +12 percent across most GFM
inputs on this machine in the same window, putting the +13 percent
residual at the upper end of that noise band.

Author: ChristianMurphy

lib/index.js

@@ -31,7 +31,13 @@ function enterFootnoteCallString() {
  * @type {FromMarkdownHandle}
  */
 function enterFootnoteCall(token) {
-  this.enter({type: 'footnoteReference', identifier: '', label: ''}, token)
+  // Trailing `position: undefined` keeps the footnoteReference 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: 'footnoteReference', identifier: '', label: '', position: undefined},
+    token
+  )
 }
 
 /**
@@ -47,8 +53,16 @@ function enterFootnoteDefinitionLabelString() {
  * @type {FromMarkdownHandle}
  */
 function enterFootnoteDefinition(token) {
+  // See enterFootnoteCall above for the rationale on the trailing
+  // position field.
   this.enter(
-    {type: 'footnoteDefinition', identifier: '', label: '', children: []},
+    {
+      type: 'footnoteDefinition',
+      identifier: '',
+      label: '',
+      children: [],
+      position: undefined
+    },
     token
   )
 }