LASSO Solve badly when alpha is extremely small

### Describe the bug

There are 2 problem:

- when `tol=1e-4`(default), the solver does not give a warning when it solved badly.
- when `alpha` is extrimely small (like 1e-8), the solver could not find solution properly.

### Steps/Code to Reproduce

In this case, solver even do not raise a warning until `tol` = 1e-5.
```python
from sklearn.linear_model import MultiTaskLasso
import numpy as np

seed = 114514
np.random.seed(seed)

m = 256
n = 512
l = 2
k = int(m*0.1)

X = np.random.randn(m, n)
u = np.zeros((n, l))
# randomly choose k rows of u
u[np.random.choice(n, k, replace=False), :] = np.random.randn(k, l)
y = np.dot(X, u)

def loss(w:np.ndarray):
    return 0.5/m * np.linalg.norm(y - np.dot(X, w), ord='fro')**2 + 0.01 * np.linalg.norm(w, ord=1, axis=0).sum()

def err_to_exact(w:np.ndarray):
    return np.linalg.norm(w - u, ord='fro')

def err_fn(w1:np.ndarray,w2:np.ndarray):
    return np.linalg.norm(w1 - w2, ord='fro')

clf = MultiTaskLasso(alpha=0.01/m)
# clf = MultiTaskLasso(alpha=0.01/m,tol=1e-5)
clf.fit(X, y)
x = clf.coef_.T
print("dual gap:",clf.dual_gap_)
print("origin u loss:",loss(u))
print("iter:{}, loss:{}, err-to-exact:{}".format(clf.n_iter_,loss(x),err_to_exact(x)))
```


### Expected Results

To solve the problem when `tol` is quite small, we should do warm up training and train the model from larger $\alpha$ to smaller.
temp solution:
```python
clf = MultiTaskLasso(alpha=1/m,tol=1e-5,warm_start=True)
for i in range(3):
    clf.fit(X,y)
    clf.alpha /= 10
```
output:
```
dual gap: 6.679412639977893e-05
origin u loss: 0.5091769015638326
iter:6, loss:0.5091640128686069, err-to-exact:0.00021114026824291122
```
should we add it into .fit method?

### Actual Results

when $tol=1e-4,\alpha=0.01/m$:
```
dual gap: 0.0060915764336923126
origin u loss: 0.5091769015638326
iter:20, loss:2.2204027219101863, err-to-exact:9.758212052573763
```
The loss is quite larger than the origin u, so it must be wrong.
when $tol=1e-5,\alpha=0.01/m$:
```
Warning: Objective did not converge. You might want to increase the number of iterations. 
Duality gap: 1.3354989080418382, tolerance: 0.22307386842917606
  ) = cd_fast.enet_coordinate_descent_multi_task(
dual gap: 0.005216792609538431
origin u loss: 0.5091769015638326
iter:1000, loss:1.9859143908713657, err-to-exact:9.067098629992879
```

### Versions

```shell
1.2.2
```

COMMENT:
There are a few reasons why this might happen:

1. Numerical Precision: Extremely small alpha values might lead to numerical precision issues. With very small regularization, the optimization problem becomes challenging to solve accurately due to the scale of the values involved.

2. Algorithm Sensitivity: LASSO optimization might be highly sensitive to very small alpha values, leading to convergence problems or poor solutions.

Here's a possible solution that incorporates warm-starting and adjusts the alpha value progressively from larger to smaller:

from sklearn.linear_model import MultiTaskLasso
import numpy as np

seed = 114514
np.random.seed(seed)


clf = MultiTaskLasso(alpha=1/m, tol=1e-5, warm_start=True)
for i in range(3):
    clf.fit(X, y)
    clf.alpha /= 10

x = clf.coef_.T
print("dual gap:", clf.dual_gap_)
print("origin u loss:", loss(u))
print("iter:{}, loss:{}, err-to-exact:{}".format(clf.n_iter_, loss(x), err_to_exact(x)))

Labels: Bug, help wanted