doc: formalize fn/name as part of TestOptions API

`TestOptions` as provided to `node:test`'s `test`/`it` supports both
`name` and `fn` as options per its implementation.

I'd like to formalize this as part of the public, documented API.

### Motivation

I have a use-case for consuming both fields.  I'd like to be able to
return the result of a function to `test`/`it` without needing to spread
 the parameters; e.g.:

```js
const testOptionsFactory = (opts = {}) => {
  return {
    fn: () => { /* .. */ },
    name: opts.name
  };
};

test(testOptionsFactory({name: 'foo'}));
```

If I cannot rely on this behavior, then I would need to instead return
an array of parameters and spread them:

```js
const testParamsFactory = (opts = {}) => {
  return opts.name !== undefined
    ? [opts.name, () => { /* .. */ }] : [() => { /* .. */ }];
};

test(...testParamsFactory({name: 'foo'}));
```

I don't think it's too terribly controversial that the former is more
ergonomic than the latter.

### Next Steps

Once this lands, I plan to propose the addition of these fields to
`@types/node`. Since the fields are not currently publicly documented, I
can't justify such a change.

Signed-off-by: Christopher Hiller <boneskull@boneskull.com>
PR-URL: #64946
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruy Adorno <ruy@vlt.sh>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>

Author: boneskull

doc/api/test.md

@@ -1954,6 +1954,10 @@ changes:
     If the number of assertions run in the test does not match the number
     specified in the plan, the test will fail.
     **Default:** `undefined`.
+  * `fn` {Function|AsyncFunction} The function under test. If provided, it will take
+    precedence over the `fn` parameter.
+  * `name` {string} The name of the test. If provided, it will take precedence over the
+    `name` parameter.
 * `fn` {Function|AsyncFunction} The function under test. The first argument
   to this function is a [`TestContext`][] object. If the test uses callbacks,
   the callback function is passed as the second argument. **Default:** A no-op

test/parallel/test-runner-option-precedence.js

@@ -0,0 +1,41 @@
+'use strict';
+require('../common');
+const { test, suite } = require('node:test');
+
+suite('test runner option precedence', () => {
+  test(
+    'overridden test name',
+    { name: 'options.name overrides test name', plan: 1 },
+    (t) => {
+      t.assert.strictEqual(t.name, 'options.name overrides test name');
+    },
+  );
+
+  test(
+    'options.fn overrides test function',
+    {
+      fn: (t) => {
+        t.assert.ok(true);
+      },
+      plan: 1,
+    },
+    (t) => {
+      t.assert.fail('should not be called');
+    },
+  );
+
+  test('options.fn only', {
+    plan: 1,
+    fn: (t) => {
+      t.assert.ok(true);
+    },
+  });
+
+  test({
+    name: 'single parameter options',
+    plan: 1,
+    fn: (t) => {
+      t.assert.ok(true);
+    },
+  });
+});