Is this the correct way to optimise code to execute once?

Lethn It's a very spaghettified way of doing it with too much repetition and poorly readable code.
You know that famous quote from Fred Brooks:
Show me your flowcharts and conceal your tables, and I shall continue to be mystified. Show me your tables, and I won't usually need your flowcharts; they'll be obvious.

What he meant is that code based on well organized data structures is easy to read and write. So you should always strive to solve a problem by figuring out best data structures to represent it. With well chosen and well named data structures, your code can become short, expressive and self-explanatory.

In this case, you're basically making a scheduler so it'd be a good idea to make each task a separate function and keep them in a dictionary together with times they need to be executed at. Now simply go through this dictionary, check if time has come to execute a task. If yes, call the task's function. To simplify time comparison, your little scheduler's internal time keeping could be in seconds, but you'll perhaps want to input time in nice HH:MM:SS format So you'll need a helper function that converts from human friendly format to seconds.
To put it all together:

extends Node

# helper function to convert HH:MM:SS strings to seconds
func to_seconds(time_string:String):
	var tokens = time_string.split(":")
	return int(tokens[0]) * 60 * 60 + int(tokens[1]) * 60 + int(tokens[2])

# Scheduled tasks
func eat():
	print("eating")

func sleep():
	print("sleeping")
	
# Schedule dictionary with task functions as values and task times (in seconds) as keys
var schedule = { 
	to_seconds("10:22:12"): eat,
	to_seconds("10:22:14"): sleep,
}

# helper function to determine if time has passed
func time_mark_passed(time_mark, time_last_frame, time_now):
	return sign(time_last_frame - time_mark) <= 0 and sign(time_now - time_mark) > 0

# current time and previous frame time
var time_now = to_seconds("10:22:10") 
var time_last_frame = time_now
				
# do the scheduling in real time
func _process(delta):
	for task_time in schedule.keys():
		if time_mark_passed(task_time, time_last_frame, time_now):
			schedule[task_time].call()
	
	time_last_frame = time_now
	time_now += delta

Note that I used real time here but it'd be exactly the same with some virtual ingame time.

Lethn You should definitely make friends with Dictionaries Associative arrays (aka dictionaries) are one of the basic concepts in programming in general. They are immensely useful for keeping all sorts of data.

Using a dictionary isn't the main thing here though.

So how to ensure that each task from the schedule is called only once?

You have to periodically iterate through all tasks in the schedule and determine if particular task's time has come. In order to do this you'll need to maintain two time stamps: current time at which you're looking at the schedule, and time you last looked at the schedule. If task's scheduled time is between these two - run it. This makes impossible for a task to be called more than once in a day. Note that the interval duration between consecutive schedule checks is not really important. Although in the example I do it every frame, it will work properly with any interval. You can do it every second, or every 5 minutes...

You could use signals for this kind of thing.

extends Node2D

# Declare signals
signal next_phase(day: bool)
signal next_hr(hr: int, day: bool)

# Declare vars to save day/night cycle state
var hour := 0
var max_hrs := 12
var day := false


# Called when the node enters the scene tree for the first time.
func _ready():
	# 1 hr in s. THIS IS IN REAL TIME
	$DayNightCycle.start(3600)
	# Every time the timer reaches 0,
	# Advance the current hour
	$DayNightCycle.timeout.connect(advance_hr)
	# Toggle day/night if necessary
	$DayNightCycle.timeout.connect(reset_hr)
	# Check if it's time to sleep
	next_hr.connect(sleep)


func advance_hr() -> void:
	hour += 1 # Advance hour
	next_hr.emit(hour, day) # Notify all connected functions


func reset_hr() -> void:
	if hour == max_hrs: # Check if the day/night is over
		hour = 0
		day = not day
		next_phase.emit(day) # Notify all connected functions


func sleep(time: int, time_of_day: bool) -> void:
	if time == 8 and not time_of_day: # Check if it's time to sleep
		print("sleep")

advance_hr() and reset_hr() will be called every time the timer reaches 0, and sleep() will be called every time that advance_hr() runs; however, the if-statements will make sure that it only runs when it's supposed to (i.e. at the 8th hr of the night). This example uses a Timer node, which counts real-world time, but it's trivial to adapt it to your own system: just declare the signals (along with any relevant state info) and emit them when you want things to happen. Then all you have to do is connect the functions from your other scripts.

If you have a ton of different villagers, you might consider making an array of Callables and using the hour as an index, e.g.

var night_tasks = [rest, rest, rest, sleep, rest, rest]


func rest():
	pass


func do_night_tasks(hr: int):
	var fn: Callable = night_tasks[hr]
	if fn:
		fn.call()


next_hr.connect(do_night_tasks)

This is easier to manipulate programmatically.