fix(react-router): fix custom link type ref inference (#4121)

Custom links created by `createLink` would incorrectly infer `ref`
values for non-intrinsic components (such as those with their own `ref`
prop like the [documented
example](https://tanstack.com/router/latest/docs/framework/react/guide/custom-link#basic-example)),
which would result in the ref being "double-wrapped". That is:

Before:
```typescript
{
  // Effective LinkComponentReactProps<TComp>
  // ...
  ref?: React.Ref<React.Ref<HTMLAnchorElement> | undefined> | undefined
  // notice the ref has been "ref'ed" twice
}
```

After fix:
```typescript
{
  // Effective LinkComponentReactProps<TComp>
  // ...
  ref?: React.Ref<HTMLAnchorElement> | undefined>
}
```

This patch, the equivilant applied directly to `link.d.ts` via `yarn
patch`, has been our workaround and it appears to work well:
<details>
<summary>@tanstack-react-router-npm-1.120.3-f6c72d7c75.patch</summary>

```patch
diff --git a/dist/esm/link.d.ts b/dist/esm/link.d.ts
index f7a4dfc2678f3669ee48b97c22e4c69d2f3ff195..be0adda3bf4302466c3c4b4d73ff6c78474a237f 100644
--- a/dist/esm/link.d.ts
+++ b/dist/esm/link.d.ts
@@ -4,9 +4,9 @@ import { ValidateLinkOptions, ValidateLinkOptionsArray } from './typePrimitives.
 import * as React from 'react';
 export declare function useLinkProps<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = ''>(options: UseLinkPropsOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>, forwardedRef?: React.ForwardedRef<Element>): React.ComponentPropsWithRef<'a'>;
 type UseLinkReactProps<TComp> = TComp extends keyof React.JSX.IntrinsicElements ? React.JSX.IntrinsicElements[TComp] : React.PropsWithoutRef<TComp extends React.ComponentType<infer TProps> ? TProps : never> & React.RefAttributes<TComp extends React.FC<{
-    ref: infer TRef;
+    ref: React.Ref<infer TRef>;
 }> | React.Component<{
-    ref: infer TRef;
+    ref: React.Ref<infer TRef>;
 }> ? TRef : never>;
 export type UseLinkPropsOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends RoutePaths<TRouter['routeTree']> | string = string, TTo extends string | undefined = '.', TMaskFrom extends RoutePaths<TRouter['routeTree']> | string = TFrom, TMaskTo extends string = '.'> = ActiveLinkOptions<'a', TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & UseLinkReactProps<'a'>;
 export type ActiveLinkOptions<TComp = 'a', TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = LinkOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & ActiveLinkOptionProps<TComp>;
```

</details>

---------

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

Author: CynicalBusiness

packages/react-router/src/link.tsx

@@ -364,8 +364,8 @@ type UseLinkReactProps<TComp> = TComp extends keyof React.JSX.IntrinsicElements
     > &
       React.RefAttributes<
         TComp extends
-          | React.FC<{ ref: infer TRef }>
-          | React.Component<{ ref: infer TRef }>
+          | React.FC<{ ref: React.Ref<infer TRef> }>
+          | React.Component<{ ref: React.Ref<infer TRef> }>
           ? TRef
           : never
       >

packages/react-router/tests/link.test-d.tsx

@@ -1,4 +1,5 @@
 import { expectTypeOf, test } from 'vitest'
+import React from 'react'
 import {
   Link,
   createLink,
@@ -9,6 +10,7 @@ import {
 } from '../src'
 import type {
   CreateLinkProps,
+  LinkComponent,
   ResolveRelativePath,
   SearchSchemaInput,
 } from '../src'
@@ -4005,6 +4007,39 @@ test('when passing a component with props to createLink and navigating to the ro
   createLink((props) => expectTypeOf(props).toEqualTypeOf<CreateLinkProps>())
 })
 
+test('that createLink refs forward correctly', () => {
+  // copied from: https://tanstack.com/router/latest/docs/framework/react/guide/custom-link#basic-example
+  interface BasicLinkProps
+    extends React.AnchorHTMLAttributes<HTMLAnchorElement> {}
+  const BasicLinkComponent = React.forwardRef<
+    HTMLAnchorElement,
+    BasicLinkProps
+  >((props, ref) => {
+    return (
+      <a ref={ref} {...props} className={'block px-3 py-2 text-blue-700'} />
+    )
+  })
+  const CreatedLinkComponent = createLink(BasicLinkComponent)
+  const CustomLink: LinkComponent<typeof BasicLinkComponent> = (props) => {
+    return <CreatedLinkComponent preload={'intent'} {...props} />
+  }
+
+  expectTypeOf(BasicLinkComponent)
+    .parameter(0)
+    .toHaveProperty('ref')
+    .toEqualTypeOf<React.Ref<HTMLAnchorElement> | undefined>()
+
+  expectTypeOf(CreatedLinkComponent)
+    .parameter(0)
+    .toHaveProperty('ref')
+    .toEqualTypeOf<Parameters<typeof BasicLinkComponent>[0]['ref']>()
+
+  expectTypeOf(CustomLink)
+    .parameter(0)
+    .toHaveProperty('ref')
+    .toEqualTypeOf<Parameters<typeof BasicLinkComponent>[0]['ref']>()
+})
+
 test('ResolveRelativePath', () => {
   expectTypeOf<ResolveRelativePath<'/', '/posts'>>().toEqualTypeOf<'/posts'>()