fix: keep requires_grad when re-wrapping a lifted parameter

[shoumikhin]

The problem

Legacy export fails when a registered parameter has an integer dtype. It breaks while the
exporter turns the graph attributes into placeholders.

Each named parameter is re-wrapped there:

state_dict[name] = torch.nn.Parameter(state_dict[name])

gm.state_dict() hands back plain tensors, so the original requires_grad flag is
already gone by this point, and Parameter puts it back as True by default. An integer
tensor cannot require gradients, so the export stops:

RuntimeError: Only Tensors of floating point and complex dtype can require gradients

This is easy to hit without any quantizer involved: constant folding registers folded
constants as parameters, so an integer constant expression reaches the same line.

There is a second, quieter problem. A float parameter the model had frozen comes back
trainable, which builds an autograd graph inside a program meant only for inference.

The fix

The loop already has the module's parameter in hand, so carry its flag across instead of
throwing it away:

for name, param in gm.named_parameters():
    if node.target == name:
        input_kind = InputKind.PARAMETER
        state_dict[name] = torch.nn.Parameter(
            state_dict[name], requires_grad=param.requires_grad
        )
        break

Nothing else about the classification changes. The weight stays a PARAMETER, stays in
the state dict as a Parameter, and stays out of the constants mapping, so loading a
checkpoint into the exported module keeps working. This matches torch.export, which
takes the input kind from module registration rather than from dtype.

Testing

Extended the existing lift() parameter test to assert the input kind, the container type
and the requires_grad flag, not just the dtype and stride. It covers both flag values, so
an implementation that hardcodes either one fails.

Checked against the current code and against three wrong implementations:

correct fix                          4 passed
hardcode requires_grad=False         1 failed
hardcode requires_grad=True          3 failed
read the flag off the state dict     1 failed
current code, no fix                 3 failed

That last mutant matters: state_dict() detaches, so reading the flag from it always
yields False and looks correct until a trainable parameter is exported.

Full file: 20 passed.

These tests live in the executorch suite, which only the nightly lane selects, so they do
not run on this PR by default.