pre_autograd `make_fx` broken with simple F.linear with symbolic shape
Labels: triaged, oncall: pt2, module: dynamic shapes

### 🐛 Describe the bug

I'm trying to get a `pre_autograd` aten_graph from dynamo with dynamic shape. The following code sort of works on `torch==2.1.0.dev20230425` but is broken with '2.1.0a0+git1c11065'

```
import torch
import torch.nn as nn
import torch._dynamo as dynamo
from torch.fx.experimental.proxy_tensor import make_fx
from torch._dispatch.python import enable_python_dispatcher
from torch._guards import detect_fake_mode

def compiler(gm, example_inputs):
    fake_mode = detect_fake_mode(example_inputs)
    fake_inputs = [fake_mode.from_tensor(i) if isinstance(i, torch.Tensor) else i
                   for i in example_inputs]
    with fake_mode, enable_python_dispatcher():
        fx_graph = make_fx(gm, pre_autograd=True)(*fake_inputs)
        print(fx_graph.graph)
    return gm.forward


@dynamo.optimize(compiler, dynamic=True)
def f(x, w, b):
    z = torch.nn.functional.linear(x, w, b)
    return z


w = torch.randn(20, 10)
b = torch.randn(20)
f(torch.randn(1, 2, 10), w, b)
f(torch.randn(1, 3, 10), w, b)

```

Output from `torch==2.1.0.dev20230425`

```
graph():
    %arg0_1 : [#users=2] = placeholder[target=arg0_1]
    %arg1_1 : [#users=1] = placeholder[target=arg1_1]
    %arg2_1 : [#users=1] = placeholder[target=arg2_1]
    %arg3_1 : [#users=1] = placeholder[target=arg3_1]
    %t : [#users=1] = call_function[target=torch.ops.aten.t.default](args = (%arg2_1,), kwargs = {})
    %view : [#users=1] = call_function[target=torch.ops.aten.view.default](args = (%arg1_1, [%arg0_1, 10]), kwargs = {})
    %addmm : [#users=1] = call_function[target=torch.ops.aten.addmm.default](args = (%arg3_1, %view, %t), kwargs = {})
    %view_1 : [#users=1] = call_function[target=torch.ops.aten.view.default](args = (%addmm, [1, %arg0_1, 20]), kwargs = {})
```

Output from  '2.1.0a0+git1c11065'
```
torch._dynamo.exc.BackendCompilerFailed: backend='compiler' raised:
RuntimeError: s0 is not tracked with proxy for <torch.fx.experimental.proxy_tensor.PythonKeyTracer object at 0x7f25897eed7
0>
```

Expected Output:
FX graph that contains "call_function[target=torch.ops.aten.linear.default]".


With `torch==2.1.0.dev20230425`, the problem is that `aten.linear.default` did not go through python dispatch, so we have a graph with "transpose + view + admm".

With '2.1.0a0+git1c11065', we have `aten.linear.default` properly go through python dispatch, and `transpose + view + admm` is going through `inside_mode` of `ProxyTorchDispatchMode`. However, within Linear.cpp, we have the following code

```
static inline Tensor _flatten_3d_linear(const Tensor& input, const Tensor& weight, const Tensor& bias) {
    const auto input_sizes = input.sym_sizes();
    const auto result = at::addmm(bias, input.view_symint({input_sizes[0] * input_sizes[1], input_sizes[2]}), weight.t());    return result.view_symint({input_sizes[0], input_sizes[1], result.sym_size(1)});
}
```
So the input to `aten::view` is a new symbol `s0 = 1 * s0` but it is somehow not tracked by `ProxyTorchDispatchMode.symnode_tracker`.

### Versions

'2.1.0a0+git1c11065'

cc @ezyang @soumith @msaroufim @wconstab @ngimel @bdhirsh