✨ Add initial pattern-matching API

Introduce the core builder and pattern constructors:

- match(value): chain .with(pattern, handler) and terminate with
  .exhaustive() (throws on no match) or .otherwise(handler).
- P.literal, P.type, P.when, P.any, P.shape for pattern construction.
- Each pattern is a Matcher<T> whose matches acts as a type guard, so
  handler parameters are narrowed to the matched type.

The MatchBuilder accumulates handlers and returns a new builder per
.with() call (immutable chaining); finalization runs the cases in order
and returns the first match's handler result.

TypeScript configuration relaxed in .oxlintrc.json:
- Disable eslint/no-undefined (we use undefined as the no-match sentinel)
- Disable eslint/sort-keys (handler order matters; alphabetical would
  be wrong)
- Disable eslint/id-length (T/R/U/V generics are standard TS convention)
- Disable import/no-named-export (false positive for library entry points)

Verified:
- tsc --noEmit passes with strict + noUncheckedIndexedAccess
- tsc -p tsconfig.build.json emits dist/*.js + .d.ts + sourcemaps
- node -e "import('./dist/index.js')" loads and exposes { match, P }

src/match.ts

@@ -0,0 +1,63 @@
+import { P, type Matcher, type Pattern } from "./pattern.js";
+
+type Cases<R> = ReadonlyArray<
+    readonly [Matcher<unknown>, (value: unknown) => R]
+>;
+
+interface MatchBuilder<T, R> {
+    with<U extends T, V>(
+        pattern: Matcher<U>,
+        handler: (value: U) => V,
+    ): MatchBuilder<T, R | V>;
+    exhaustive(): R;
+    otherwise(handler: (value: T) => R): R;
+}
+
+const buildMatch = <T, R>(value: T, cases: Cases<R>): MatchBuilder<T, R> => {
+    const apply = (): R | undefined => {
+        for (const [matcher, handler] of cases) {
+            if (matcher.matches(value as unknown)) {
+                return handler(value);
+            }
+        }
+        return undefined;
+    };
+
+    const builder = {
+        with<U extends T, V>(
+            pattern: Matcher<U>,
+            handler: (value: U) => V,
+        ): MatchBuilder<T, R | V> {
+            const nextCases: Cases<R | V> = [
+                ...cases,
+                [pattern, handler as (value: unknown) => R | V],
+            ];
+            return buildMatch(value, nextCases);
+        },
+        exhaustive(): R {
+            const result = apply();
+            if (result === undefined) {
+                throw new Error(
+                    "tiny-pattern-ts: match.exhaustive() called with no matching case",
+                );
+            }
+            return result;
+        },
+        otherwise(handler: (value: T) => R): R {
+            for (const [matcher, run] of cases) {
+                if (matcher.matches(value as unknown)) {
+                    return run(value) as R;
+                }
+            }
+            return handler(value);
+        },
+    };
+
+    return builder;
+};
+
+export const match = <T>(value: T): MatchBuilder<T, never> =>
+    buildMatch<T, never>(value, []);
+
+export type { Matcher, Pattern };
+export { P };