Hangs in LogisticRegression with high intercept_scaling number

### Describe the bug

When using the `LogisticRegression` model with the solver set to `liblinear` and specifying the `intercept_scaling` parameter, the model hangs without any clear reason. The processing time does not increase gradually with the size of the `intercept_scaling` parameter.

### Steps/Code to Reproduce

When running on my machine, the code below complete in around 7 seconds.
```python
from sklearn.linear_model import LogisticRegression

model = LogisticRegression(
        intercept_scaling=1.0e+77,
        solver='liblinear',
        )

model.fit([[0], [5]], [0, 6])
```

However, increasing `intercept_scaling` by just one decimal place causes the model to hang indefinitely:
```python
from sklearn.linear_model import LogisticRegression

model = LogisticRegression(
        intercept_scaling=1.0e+78,
        solver='liblinear',
        )

model.fit([[0], [5]], [0, 6])
```

### Expected Results

I expect the code to finish running in a reasonable time.

When `intercept_scaling` is set as 1.0e+77, the program finished in around 7 sec.

### Actual Results

I terminated the process by after a day, no error trace was given by the program.

```javascript
Command terminated by signal 15
	Command being timed: "python Aidan2.py"
	User time (seconds): 94481.23
	System time (seconds): 12.59
	Percent of CPU this job got: 99%
	Elapsed (wall clock) time (h:mm:ss or m:ss): 26:15:08
	Average shared text size (kbytes): 0
	Average unshared data size (kbytes): 0
	Average stack size (kbytes): 0
	Average total size (kbytes): 0
	Maximum resident set size (kbytes): 142780
	Average resident set size (kbytes): 0
	Major (requiring I/O) page faults: 3
	Minor (reclaiming a frame) page faults: 25293
	Voluntary context switches: 69
	Involuntary context switches: 537213
	Swaps: 0
	File system inputs: 256
	File system outputs: 0
	Socket messages sent: 0
	Socket messages received: 0
	Signals delivered: 0
	Page size (bytes): 4096
	Exit status: 0
```

### Versions

```shell
System:
    python: 3.13.3 (main, Apr 22 2025, 19:24:41) [GCC 11.4.0]
executable: /home/venv/bin/python
   machine: Linux-6.8.0-57-generic-x86_64-with-glibc2.35

Python dependencies:
      sklearn: 1.6.1
          pip: 25.0.1
   setuptools: 79.0.0
        numpy: 2.2.3
        scipy: 1.15.2
       Cython: None
       pandas: 2.2.3
   matplotlib: None
       joblib: 1.4.2
threadpoolctl: 3.5.0

Built with OpenMP: True

threadpoolctl info:
       user_api: blas
   internal_api: openblas
    num_threads: 28
         prefix: libscipy_openblas
       filepath: /home/venv/lib/python3.13/site-packages/numpy.libs/libscipy_openblas64_-6bb31eeb.so
        version: 0.3.28
threading_layer: pthreads
   architecture: Haswell

       user_api: blas
   internal_api: openblas
    num_threads: 28
         prefix: libscipy_openblas
       filepath: /home/venv/lib/python3.13/site-packages/scipy.libs/libscipy_openblas-68440149.so
        version: 0.3.28
threading_layer: pthreads
   architecture: Haswell

       user_api: openmp
   internal_api: openmp
    num_threads: 28
         prefix: libgomp
       filepath: /home/venv/lib/python3.13/site-packages/scikit_learn.libs/libgomp-a34b3233.so.1.0.0
        version: None
```

COMMENT:
I don't think it'd be worth investigating @jasneetsingh6114 . At those levels of intercept scaling, we probably would have other numerical issues than the algorithm hanging. I don't think this is a reasonable actual usecase reproducer. So I'm inclined to close as "wontfix" unless a real usecase comes up.

Labels: Bug