Arduino Uno stops in Sketch

Unfortunately that is completely useless change and won't do anything to fix your problem.

Prompted by @Danois90 I have had another closer look at your code and it is the cleanest use of String I have ever seen.
You sketch uses ZERO long term heap.

The heap manager and the compiler is much better than you might imagine.
There is no allocated or fragmented heap once loop() returns.

Even inside the loop(), the heap usage is minimal and returns to zero between statements.

The trick is you only ever use String in print( .. ) statements and the compiler correctly completely disposes of the Strings when that statement returns and the heap manager completely recovers the heap used (without leaving any holes)

SO String usage is definitely not the cause of your problem.
Other things to look at are noise on the power supply or sagging voltage which causes the BOD (BrownOutDetector) to trigger.
Are you running the ESP from the same supply? The ESP can draw a lot of current when sending >200mA

Removing the debugging prints will probably not help either. The prints block until the UART has space in its 64 byte TX buffer but that is the only issue there and your delays are so long you would not notice. See my Arduino Serial I/O for the Real World tutorial for all the details.
Certainly when I ran your code here for a few hours with seconds delays instead of hours, it ran with no problems with all the prints enabled. Once you call Serial.begin( ) the UART will just send the chars in the background even if nothing is connected.

The Uno, the ESP and the relays all have an extra power supply. Only the thermometer I have connected to the Uno with 5v.I have freewheeling diodes for the solenoid valves and a snubber for the pump.
Since the reset everything runs perfectly as before.

Following @Danois90 good suggestion re a flashing led here is your code recast as a series of tasks with a flashing led added (pin 11 since you are using pin 13).
The code changes are minimal and still leave some longish delays which will cause the led to stop flashing for 20sec of so, but should give you some idea it is still running.

See How to write Timers and Delays in Arduino
and Multi-tasking in Arduino

// download SafeString V4.1.5+ library from the Arduino Library manager or from
// https://www.forward.com.au/pfod/ArduinoProgramming/SafeString/index.html
// for the millisDelay class
#include "millisDelay.h"

int led = 11;
// Pin 11 has an LED connected
bool ledOn = false; // keep track of the led state
millisDelay ledDelay;

millisDelay delayToWarmUp;
millisDelay readDelay;
const unsigned long readDelay_mS = 5000; // for testing real time 60ul*1000;
millisDelay powerOffDelay;
const unsigned long powerOffDelay_mS = 1000;
const unsigned long hrs_12 = 20000;// for testing real time  12UL * 60UL * 60UL * 1000UL;
const unsigned long hrs_1 = 20000;// for testing real time 1UL * 60UL * 60UL * 1000UL;


//define soil moisture in the next line
int SoilTomato = 650;        // Summer 2021 Soil 610 hot / 630 normal
int SoilGround = 680;        // Summer 2021 Soil 650 hot / 680 normal
int WaterLevel = 800;         // Waterlevel, water tank greater than 800 then empty
int tomatoRead;              //Cache the measurement value.
int groundRead;              //Cache the measurement value.
int waterRead;               //Cache the measurement value.


//int Sensor = A0;            //Senor pin plant
const byte SensorPower = 7;   //Power pin plant - use digital I/O pin
const byte SensorGnd = 8;     //Gnd pin plant - use digital I/O pin
const byte Sensor = A0;       //Sensor pin plant

//int Sensor2 = A1;           //Senor pin water lever
const byte SensorPower2 = 12; //Power pin water level - use digital I/O pin
const byte SensorGnd2 = 13;   //Gnd pin water level - use digital I/O pin
const byte Sensor2 = A1;      //Sensor pin water level

//int Sensor3 = A2;           //Senor pin plant - ground
const byte SensorPower3 = 9;  //Power pin water level - use digital I/O pin
const byte SensorGnd3 = 10;   //Gnd pin water level - use digital I/O pin
const byte Sensor3 = A2;      //Sensor pin water level

//relay solenoid valve
int pumpPin = 4;              //1.
//int pumpPin2 = 3;             //2. Tomato - Solenoid valve pin, solenoid valve
int pumpPin2 = A4;             //2. Tomato - Solenoid valve pin, solenoidvalve
int pumpPin3 = 6;             //3. Ground - Solenoid valve pin,solenoidvalve
int pumpPin4 = 5;             //4. Ground2 - Solenoid valve pin, solenoidvalve

// SSR pump
//int relayPin = 2;   // set pin 2 for relay output
int relayPin = A3;   // set pin 2 for relay output


//Serial Data for Wemos D1 mini
#include <SoftwareSerial.h>
SoftwareSerial espSerial(2, 3); //RX, TX

//Temp LM35
float tempC;
int tempRead;
int tempPin = A5; // Define to which pin of the Arduino the output of the LM35 is connected:

int waterReadEnd = 0;


void checkToggleLed() { // led task
  // check if delay has timed out
  Serial.print('.');
  if (ledDelay.justFinished()) {
    Serial.print('+');
    ledDelay.restart(); //
    // toggle the led
    ledOn = !ledOn;
    if (ledOn) {
      digitalWrite(led, HIGH); // turn led on
    } else {
      digitalWrite(led, LOW); // turn led off
    }
  }
  Serial.println();
}

void setup() {

  digitalWrite(pumpPin, HIGH);     // Relais wird nichtgestartet,Prevents relays from starting up engaged
  digitalWrite(pumpPin2, HIGH);    // Relais wird nichtgestartet,Prevents relays from starting up engaged
  digitalWrite(pumpPin3, HIGH);    // Relais wird nichtgestartet,Prevents relays from starting up engaged
  digitalWrite(pumpPin4, HIGH);    // Relais wird nichtgestartet,Prevents relays from starting up engaged

  pinMode(pumpPin, OUTPUT);
  pinMode(pumpPin2, OUTPUT);
  pinMode(pumpPin3, OUTPUT);
  pinMode(pumpPin4, OUTPUT);

  pinMode(relayPin, OUTPUT);


  Serial.begin(9600);
  Serial.println("Watering-System is online");
  espSerial.begin(9600);  //ESP-Data
  delayToWarmUp.start(10000); // wait 10 sec to do first warm up
  //delay(10000);
  espSerial.println("<Watering-System is online>");

  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);   // initialize the digital pin as an output.
  digitalWrite(led, LOW); // turn led off
  ledOn = false;
  // start delay
  ledDelay.start(500);
}

void warmup() {
  if (!delayToWarmUp.justFinished()) {
    return; //not yet wait
  }
  //********* Round 1 ***************

  Serial.println(F("***Start measuring plant in 60s! warmuup Sensor***"));

  pinMode(SensorPower, OUTPUT);
  pinMode(SensorPower2, OUTPUT);
  pinMode(SensorPower3, OUTPUT);
  pinMode(SensorGnd, OUTPUT);
  pinMode(SensorGnd2, OUTPUT);
  pinMode(SensorGnd3, OUTPUT);
  digitalWrite(SensorPower, HIGH);
  digitalWrite(SensorPower2, HIGH);
  digitalWrite(SensorPower3, HIGH);
  digitalWrite(SensorGnd, LOW);
  digitalWrite(SensorGnd2, LOW);
  digitalWrite(SensorGnd3, LOW);

  readDelay.start(readDelay_mS);
  //delay(60000);                       //warmup Time
}

void readSendData() {
  if (!readDelay.justFinished()) {
    return; // not yet wait
  }
  // temp reading with warumup
  //***************
  tempRead = analogRead(tempPin);
  delay(1000);
  tempRead = analogRead(tempPin);
  delay(1000);

  float voltage = tempRead * (5000 / 1024.0); // Convert the reading into voltage:
  float tempC = voltage / 10;    // Convert the voltage into the temperature in degree Celsius:


  // Print the temperature in the Serial Monitor:
  Serial.print("temperature: ");
  Serial.print(tempC, 1);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.println("C");
  delay(1000);

  //****************

  int tomatoRead =  analogRead(A0); //cache the measurement value.
  int groundRead =  analogRead(A2); //cache the measurement value.
  int waterRead = analogRead(A1); //cache the measurement value.

  //Serial.print("plant-tomato:");
  //Serial.println(analogRead(A0));
  Serial.println("plant-tomato: " + String(tomatoRead));
  delay(500);
  //Serial.print("plant-ground:");
  //Serial.println(analogRead(A2));
  Serial.println("plant-ground: " + String(groundRead));
  delay(500);
  Serial.print("water level:");
  Serial.println(analogRead(A1));
  delay(500);

  // 1. sensor and pump Tomato:

  if ((tomatoRead < SoilTomato) && (analogRead(A1) < WaterLevel)) {
    Serial.println("Soil Tomato still moist: " + String(tomatoRead) + ", Water tank filled.");
    //espSerial.println("<Tomato moist: " + String(tomatoRead) + ", tank filled.>");
  }

  if ((analogRead(A0) < SoilTomato) && (analogRead(A1) > WaterLevel)) {
    Serial.println("Soil Tomato still moist: " + String(tomatoRead) + ", empty water tank!!!");
    //espSerial.println("<Tomato moist: " + String(tomatoRead) + ", empty tank!!!>");
  }

  if ((analogRead(A0) > SoilTomato) && (analogRead(A1) > WaterLevel)) {
    Serial.println("Soil Tomato dry: " + String(tomatoRead) + ", empty water tank!!!");
    //espSerial.println("<Tomato dry: " + String(tomatoRead) + ", empty tank!!!>");
  }

  if ((analogRead(A0) > SoilTomato) && (analogRead(A1) < WaterLevel)) {

    //int tomatoRead =  analogRead(A0); //cache the measurement value.
    digitalWrite(relayPin, HIGH);
    Serial.println(F("pump-on:"));
    delay(2000);                                          //pump pressure delay 2 sec
    digitalWrite(pumpPin2, LOW);
    Serial.println(F("Tomato-valve-on:"));
    delay(20000); //1/2 watering time
    digitalWrite(relayPin, LOW);
    Serial.println(F("pump-off:"));
    digitalWrite(pumpPin2, HIGH);
    Serial.println(F("Tomato-valve-off:"));
    Serial.println(F("watering tomato successfully"));
    espSerial.println("<watering tomato successfully --" + String(tomatoRead) + "-- Temp: " + String(tempC, 1) + " \xC2\xB0" + "C>");
  }


  // 1. sensor and pump Ground:

  if ((groundRead < SoilGround) && (analogRead(A1) < WaterLevel)) {
    Serial.println(("Soil Ground still moist: " + String(groundRead) + ", Water tank filled."));
    //espSerial.println("<Ground moist: " + String(groundRead) + ", tank filled.>");
  }

  if ((groundRead < SoilGround) && (analogRead(A1) > WaterLevel)) {
    Serial.println(("Soil Ground still moist: " + String(groundRead) +
                    ", empty water tank!!!"));
    //espSerial.println("<Ground moist: " + String(groundRead) + ", empty tank!!!>");
  }

  if ((groundRead > SoilGround) && (analogRead(A1) > WaterLevel)) {
    Serial.println(("Soil Ground dry: " + String(groundRead) + ", empty water tank!!!"));
    //espSerial.println("<Ground dry: " + String(groundRead) + ", empty tank!!!>");
  }

  if ((groundRead > SoilGround) && (analogRead(A1) < WaterLevel)) {
    Serial.println(("Soil Ground dry: " + String(groundRead) + ", Water tank filled."));
  }

  if ((groundRead > SoilGround) && (analogRead(A1) < WaterLevel)) {

    //int groundRead =  analogRead(A2); //cache the measurement value.
    digitalWrite(relayPin, HIGH);
    Serial.println(F("pump-on:"));
    delay(2000); //pumppressure delay 2 Sec
    digitalWrite(pumpPin3, LOW);
    Serial.println(F("Ground1-valve-on:"));
    delay(25000); //watering time
    digitalWrite(pumpPin3, HIGH);
    Serial.println(F("Ground1-valve-off:"));

    delay(2000);                                         //Break 2 Sec

    digitalWrite(pumpPin4, LOW);
    Serial.println(F("Ground2-valve-on:"));
    delay(25000); //watering time
    digitalWrite(relayPin, LOW);
    Serial.println(F("pump-off:"));
    digitalWrite(pumpPin4, HIGH);
    Serial.println(F("ground2-valve-off:"));

    Serial.println(F("watering ground successfully"));
    espSerial.println("<watering ground successfully --" + String(groundRead) + "-- Temp: " + String(tempC, 1) + " \xC2\xB0" + "C>");
  }

  int waterReadEnd = analogRead(A1); //cache the measurement value.
  powerOffDelay.start(powerOffDelay_mS);
}

void powerOff() {
  if (!powerOffDelay.justFinished()) {
    return; // not yet wait
  }

  //poweroff
  { Serial.println(F("***Measurement done. Disconnecting sensor.***"));
    pinMode(SensorPower, INPUT);
    pinMode(SensorGnd, INPUT);
    pinMode(SensorPower2, INPUT);
    pinMode(SensorGnd2, INPUT);
    pinMode(SensorPower3, INPUT);
    pinMode(SensorGnd3, INPUT);
  }

  Serial.print("waterlevel:");
  Serial.println(waterReadEnd);

  if (waterReadEnd > WaterLevel) {
    Serial.println("no water");
    Serial.println("delay 12h");
    espSerial.println("<no water>");
    // set delay to next warmup
    delayToWarmUp.start(hrs_12);
    //delay(12UL * 60UL * 60UL * 1000UL); //12hour, x hours each of 60 minutes each of 60 seconds each of 1000 milliseconds all unsigned longs
  } else {
    Serial.println("delay 1h");
    delayToWarmUp.start(hrs_1);
    //delay(1UL * 60UL * 60UL * 1000UL); //1hour
  }

  // delay(3600000); // 1hour
  //  delay(7200000); // 2hour
}

void loop() {
  checkToggleLed();
  warmup();
  readSendData();
  powerOff();
  //delay(1000);
}

You could also just use this simple approach to blink an LED during delay periods:

#define DELAY_BLINK_LED LED_BUILTIN
#define DELAY_BLINK_INTERVAL 1000

void blink_delay(uint32_t delay_ms)
{
  static uint32_t toggle_ms = 0;
  static uint8_t led_state = 0;
  uint32_t start_ms = millis(), cur_ms;
  do
  {
    cur_ms = millis();
    if (cur_ms - toggle_ms >= DELAY_BLINK_INTERVAL)
    {
      toggle_ms = cur_ms;
      led_state ^= 1;
      digitalWrite(DELAY_BLINK_LED, led_state);
    }
  } while (cur_ms - start_ms < delay_ms);
}

void setup()
{
  pinMode(DELAY_BLINK_LED, OUTPUT);
  Serial.begin(9600);
}

void loop()
{
  Serial.println("LOOP!");
  blink_delay(500);
  blink_delay(5000);
  blink_delay(300);
  blink_delay(569);
  blink_delay(2500);
  blink_delay(500);
}

The code is untested an may require adjustments.

I have now taken the sketch from @drmpf. I have swapped pins 11 and 13. Now the LED_BUILTIN flashes on the Uno and the skecht still runs. Thanks for your help.
Again to understand. The blinking now says that the code is running on the UNO. As long as it is blinking the code of the UNO is ok and the UNO is working correctly? If it should not work now again then something else is the problem. Hardware, cables and so on...

That is correct. But remember the led may stop blinking for 20sec or so due the the remaining delays in your loop.
The Wemos D1 has a number of pins available so you could add leds there also. Perhaps one for connected to the router, and toggle another one for each msg from the Uno, then add small ignorable send (one char will do) from the UNO each time it flashes it led.
So both sides should flash about the same if all is well.