doc: add skipPrototypeComparison option to Assert class

Author: miguelmarcondesf

doc/api/assert.md

@@ -229,11 +229,20 @@ The `Assert` class allows creating independent assertion instances with custom o
 
 ### `new assert.Assert([options])`
 
+<!-- YAML
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/00000
+    description: Added `skipPrototypeComparison` option.
+-->
+
 * `options` {Object}
   * `diff` {string} If set to `'full'`, shows the full diff in assertion errors. Defaults to `'simple'`.
     Accepted values: `'simple'`, `'full'`.
   * `strict` {boolean} If set to `true`, non-strict methods behave like their
     corresponding strict methods. Defaults to `true`.
+  * `skipPrototypeComparison` {boolean} If set to `true`, skips prototype and constructor
+    comparison in deep equality checks. Defaults to `false`.
 
 Creates a new assertion instance. The `diff` option controls the verbosity of diffs in assertion error messages.
 
@@ -245,7 +254,8 @@ assertInstance.deepStrictEqual({ a: 1 }, { a: 2 });
 ```
 
 **Important**: When destructuring assertion methods from an `Assert` instance,
-the methods lose their connection to the instance's configuration options (such as `diff` and `strict` settings).
+the methods lose their connection to the instance's configuration options (such
+as `diff`, `strict`, and `skipPrototypeComparison` settings).
 The destructured methods will fall back to default behavior instead.
 
 ```js
@@ -259,6 +269,25 @@ const { strictEqual } = myAssert;
 strictEqual({ a: 1 }, { b: { c: 1 } });
 ```
 
+The `skipPrototypeComparison` option affects all deep equality methods:
+
+```js
+function Foo(a) { this.a = a; }
+
+function Bar(a) { this.a = a; }
+
+const foo = new Foo(1);
+const bar = new Bar(1);
+
+// Default behavior - fails due to different constructors
+const assert1 = new Assert();
+assert1.deepStrictEqual(foo, bar); // AssertionError
+
+// Skip prototype comparison - passes if properties are equal
+const assert2 = new Assert({ skipPrototypeComparison: true });
+assert2.deepStrictEqual(foo, bar); // OK
+```
+
 When destructured, methods lose access to the instance's `this` context and revert to default assertion behavior
 (diff: 'simple', non-strict mode).
 To maintain custom options when using destructured methods, avoid