NuSVC argument `class_weight` is not used

### Describe the bug

Like `SVC`, the class `NuSVC` takes argument `class_weight`. However, it looks like this argument is not used. After a quick look at the libsvm C code within sklearn as well as [libsvm's original documentation](https://www.csie.ntu.edu.tw/~cjlin/libsvm/), this seems to be expected: "`wi` set the parameter C of class i to weight*C, for C-SVC". I suggest that this argument should be removed from `NuSVC`'s constructor and from the documentation.

### Steps/Code to Reproduce

```python
from sklearn.svm import SVC, NuSVC

X = [[1., 2, 3], [0, 5, 2]]
y = [-1, 1]

NuSVC(verbose=True).fit(X, y).dual_coef_

optimization finished, #iter = 0
C = 2.587063
obj = 1.293532, rho = 0.000000
nSV = 2, nBSV = 0
Total nSV = 2
Out: [LibSVM]array([[-1.29353162,  1.29353162]])

SVC(C=2.587063, verbose=True).fit(X, y).dual_coef_

optimization finished, #iter = 1
obj = -1.293532, rho = 0.000000
nSV = 2, nBSV = 0
Total nSV = 2
Out: [LibSVM]array([[-1.29353162,  1.29353162]])

NuSVC(class_weight={-1:1.5, 1:.2}, verbose=True).fit(X, y).dual_coef_

optimization finished, #iter = 0
C = 2.587063
obj = 1.293532, rho = 0.000000
nSV = 2, nBSV = 0
Total nSV = 2
Out: [LibSVM]array([[-1.29353162,  1.29353162]])

SVC(C=2.587063, class_weight={-1:1.5, 1:.2}, verbose=True).fit(X, y).dual_coef_

optimization finished, #iter = 1
obj = -0.827860, rho = -0.600000
nSV = 2, nBSV = 1
Total nSV = 2
Out: [LibSVM]array([[-0.5174126,  0.5174126]])


NuSVC(class_weight={-1:0, 1:0}).fit(X, y).dual_coef_
Out: array([[-1.29353162,  1.29353162]])

SVC(class_weight={-1:0, 1:0}).fit(X, y).dual_coef_
Out: array([], shape=(1, 0), dtype=float64)
```


### Expected Results

As in the case of no `class_weight`, `NuSVM` should give the same `dual_coef_` as an `SVC` with the same `C`.
Also `class_weight={-1:0, 1:0}` should give the "empty" result.

### Actual Results

In all cases above `NuSVM` with class weight behaves exactly as when no weights are given.

### Versions

```shell
System:
    python: 3.9.16 | packaged by conda-forge | (main, Feb  1 2023, 21:39:03)  [GCC 11.3.0]
executable: .../bin/python3.9
   machine: Linux-6.8.0-48-generic-x86_64-with-glibc2.39

Python dependencies:
      sklearn: 1.5.2
          pip: 23.0.1
   setuptools: 67.6.0
        numpy: 2.0.2
        scipy: 1.13.1
       Cython: None
       pandas: None
   matplotlib: 3.9.2
       joblib: 1.4.2
threadpoolctl: 3.5.0

Built with OpenMP: True

threadpoolctl info:
       user_api: blas
   internal_api: blis
    num_threads: 1
         prefix: libblis
       filepath: .../lib/libblis.so.4.0.0
        version: 0.9.0
threading_layer: pthreads
   architecture: skx

       user_api: openmp
   internal_api: openmp
    num_threads: 8
         prefix: libgomp
       filepath: .../lib/libgomp.so.1.0.0
        version: None
```

COMMENT:
I discussed this issue with @adrinjalali and others yesterday, and we decided to go the [`class_weight` to `sample_weight` conversion route](https://github.com/scikit-learn/scikit-learn/issues/30332#issuecomment-2504801670) even if we cannot make the model pass the `check_sample_weight_equivalence_on_dense_data` checks at this time (hoping we will be able to fix that in the future).

For now, we can write a dedicated test for `NuSVC` with `class_weight` even if it's not as statistically accurate as the kind of things we do in `check_sample_weight_equivalence_on_dense_data`. For instance, we could just check that fitting with `class_weight` is equivalent to fitting with `sample_weight` in a specific case such as:

```python
import numpy as np
from sklearn.svm import NuSVC
from sklearn.utils._testing import assert_allclose

rng = np.random.default_rng(0)
n_per_class = 100
X = np.concatenate(
    [rng.normal(size=(n_per_class, 1)) - 10, rng.normal(size=(n_per_class, 1)) + 10],
    axis=0,
)
y = np.concatenate([np.repeat("a", n_per_class), np.repeat("b", n_per_class)])

# Check that NuSVC defaults to a near symmetric decision function when the training
# data is approximately symmetric and no weights are provided.
nu = 0.1
unweighted_clf = NuSVC(nu=nu).fit(X, y)
assert unweighted_clf.predict([[-0.1], [0.1]]).tolist() == ["a", "b"]

# Check that fitting with sample_weight can tilt the decision function towards
# classifying more "b"s.
sample_weight = np.concatenate(
    [np.repeat(0.5, n_per_class), np.repeat(2.0, n_per_class)]
)
sample_weighted_clf = NuSVC(nu=nu).fit(X, y, sample_weight=sample_weight)
assert sample_weighted_clf.predict([[-0.1], [0.1]]).tolist() == ["b", "b"]

# Check that we can achieve the same result by setting class_weight.
class_weighted_clf = NuSVC(nu=nu, class_weight={"a": 0.5, "b": 2}).fit(X, y)
assert class_weighted_clf.predict([[-0.1], [0.1]]).tolist() == ["b", "b"]

# Check strict equivalence of the decision function between the sample_weight and
# class_weight cases.
X_test = np.concatenate(
    [rng.normal(size=(n_per_class, 1)) - 10, rng.normal(size=(n_per_class, 1)) + 10],
    axis=0,
)
assert_allclose(
    sample_weighted_clf.decision_function(X_test),
    class_weighted_clf.decision_function(X_test),
)
```

Note that we still need several non-identical data-points per class (hence the random values), otherwise `fit` would be become infeasible for most choices of the `nu` parameter.

Labels: Bug, Needs Investigation