You can achieve this using only 2 more parameters in px.line:

• markers=True
• color_discrete_sequence=my_plotly_continuous_sequence

The complete code would look something like this (Note the list slicing [::4] so that the colors are well spaced):

import plotly.express as px
import pandas as pd
import numpy as np

x = [1, 2, 3, 4, 5, 6]

df = pd.DataFrame(
    {
        'x': x * 3,
        'y': list(np.array(x)) + list(np.array(x) ** 2) + list(np.array(x) ** .5),
        'color': list(np.array(x) * 0) + list(np.array(x) * 0 + 1) + list(np.array(x) * 0 + 2),
    }
)

fig = px.line(
    df,
    x='x',
    y='y',
    color='color',
    color_discrete_sequence=px.colors.sequential.Plasma[::4],
    markers=True,
    template='plotly'
)
fig.show()

This produces the following output.

In case you have more lines than the colors present in the colormap, you can construct a custom colorscale so that you get one complete sequence instead of a cycling sequence:

rgb = px.colors.convert_colors_to_same_type(px.colors.sequential.RdBu)[0]

colorscale = []
n_steps = 4  # Control the number of colors in the final colorscale
for i in range(len(rgb) - 1):
    for step in np.linspace(0, 1, n_steps):
        colorscale.append(px.colors.find_intermediate_color(rgb[i], rgb[i + 1], step, colortype='rgb'))

fig = px.line(df_e, x='temperature', y='probability', color='year', color_discrete_sequence=colorscale, height=900)
fig.show()

You should add new plots to the first one, I have a small number of samples to plot, you can play with other configurations as you want:

import plotly.express as px
import plotly.graph_objects as go
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import geopandas as gpd
from openpyxl import load_workbook
import numpy as np
import pandas as pd
from io import StringIO

import numpy as np; 
np.random.seed(0)
import seaborn as sns;




data = '''
x   y   Base_TT
14.1315559  55.75811117 1.871884861
14.66228957 57.02751992 1.599971112
14.49407157 56.06563489 1.307165278
13.21996788 55.4786748  1.411554445
14.00501286 55.72120854 1.968138334
12.73736102 56.71097302 1.309849028
14.56668525 56.74872925 1.719116945
13.24138764 56.41359089 2.000620417
14.94308088 56.54283706 1.668724723
14.5744739  56.05695327 1.266861528
'''

df_centroid_Coord = pd.read_csv(StringIO(data), delim_whitespace=True)


data = '''
ID "Ambulance station name" Longtitude Latitude
0 1 AImhult 14.128734 56.547992
1 2 Angelhdm 12.870739 56.242114
2 3 Alvesta 14.549503 56.920740
3 4 "Ostra Ljungby" 13.057450 56.188099
4 5 Broby 14.080958 56.254481
5 6 Bromölla 14.466869 56.072272
6 7 Försláv 12.814913 56.350098
7 9 Hasslehdm 13.778234 56.161536
8 10 Haganas 12.556995 56.206016
9 11 Hörby 13.643265 55.849811
10 12 "Halmstad.Vaster" 12.819960 56.674306 
'''

df_station = pd.read_csv(StringIO(data), delim_whitespace=True) 
df_station.rename(columns={'Longtitude':'x', 'Latitude':'y'}, inplace=True)
df_centroid_Coord['Ambulance_Treatment_Time'] = df_centroid_Coord ['Base_TT']

fig = px.scatter(df_centroid_Coord, x="x", y="y", 
                 title="Southern Region Centroids", 
                 color='Ambulance_Treatment_Time', 
                 log_x=True,
                 size_max=60, 
                 color_continuous_scale='Reds',
                 range_color=(0.5,2),
                 )

fig.update_traces(marker={'size': 4, 'symbol': 1})
fig.add_trace(go.Scatter(x=df_station['x'],
                         y=df_station['y'],
                         mode='markers+text',
                         text=df_station['Ambulance station name'],
                         textposition='top center',
                         showlegend=True,
                         marker=dict(
                             size=8,
                             symbol=2,
                             color='black'
                         )
                        )
             )



fig.show()

I think the best method would be to use one trace to create the boxplot, and another trace to create a scatterplot of the points. You have more parameters you can set in a scatterplot, and you can also set the colorscale of the marker in a dictionary: by passing an array with 0 mapped to dark red, 0.5 mapped to transparent grey (opacity = 0), and 1 mapped to dark green.

Since the boxplot is categorical, and you passed the parameter name='Markers', if we set the y values of the scatterplot to 'Markers' the scatterplot of the points will be superimposed on top of the boxplot. Also, as an aside, it's a good idea to set a seed to ensure reproducibility.

import random
import numpy as np 
import plotly.graph_objects as go

np.random.seed(42)
rand = np.random.uniform(-100, 100, 100)

fig = go.Figure()
fig.add_trace(go.Box(
    x=rand,
    name='Markers',
    showlegend=True,
    jitter=0,
    pointpos=0,
    line_color='rgba(128, 128, 128, .0)',
    fillcolor='rgba(128, 128, 128, .3)',
))

## add the go.Scatter separately from go.Box so we can adjust more marker parameters
## the colorscale parameter goes from 0 to 1, but will scale with your range of -100 to 100
## the midpoint is 0.5 which can be grey (to match your boxplot) and have an opacity of 0 so it's transparent
fig.add_trace(go.Scatter(
    x=rand,
    y=['Markers']*len(rand),
    name='Markers',
    mode="markers",
    marker=dict(
        size=16,
        cmax=100,
        cmin=-100,
        color=rand,
        colorscale=[[0, 'rgba(214, 39, 40, 0.85)'],   
               [0.5, 'rgba(128, 128, 128, 0)'],  
               [1, 'rgba(6,54,21, 0.85)']],
    ),
    showlegend=False
)).data[0]
fig.update_layout(template='plotly_white')
fig.show()

You need a jitter. I applied a pseudo-jitter function to the y-axis to create a scatter plot. The jitter function was inspired by the contents of this page. It may differ from the original graphing logic. At first, I wrote the graph by extracting the days of the week in a loop process, but since the color scale duplicates, I described all the days of the week and added the color scale only for Saturday since Saturday contains the largest value.

import plotly.graph_objects as go
import plotly.express as px
import numpy as np

df = px.data.tips()
N = len(df)

fig = go.Figure()

dfs = df.query('day == "Sun"')
fig.add_trace(go.Scatter(
    x=dfs['total_bill'], 
    y=0 + np.random.rand(N) * 0.2,
    mode='markers',
    marker=dict(
        size=9,
        color=dfs['total_bill'],
    ),
    name='Sun',
))

dfst = df.query('day == "Sat"')
fig.add_trace(go.Scatter(
    x=dfst['total_bill'], 
    y=1 + np.random.rand(N) * 0.2,
    mode='markers',
    marker=dict(
        size=9,
        color=dfst['total_bill'],
        colorbar=dict(
            title='total_bill',
        ),
        colorscale='Plasma'
    ),
    name='Sat',
))

dfth = df.query('day == "Thur"')
fig.add_trace(go.Scatter(
    x=dfth['total_bill'], 
    y=2 + np.random.rand(N) * 0.2,
    mode='markers',
    marker=dict(
        size=9,
        color=dfth['total_bill'],
    ),
    name='Thur',
))

dff = df.query('day == "Fri"')
fig.add_trace(go.Scatter(
    x=dff['total_bill'], 
    y=3 + np.random.rand(N) * 0.2,
    mode='markers',
    marker=dict(
        size=9,
        color=dff['total_bill'],
    ),
    name='Fri',
))

fig.update_layout(showlegend=False, coloraxis_showscale=True)
fig.update_yaxes(tickvals=[0,1,2,3], ticktext=['Sun','Sat','Thur','Fri'])
fig.show()