### Godot version

4.1 stable

### System information

Godot v4.1.stable - Artix Linux #1 SMP PREEMPT_DYNAMIC Thu, 03 Nov 2022 21:10:08 +0000 - Vulkan (Forward+) - dedicated NVIDIA GeForce GTX 1050 Ti (nvidia; 520.56.06) - AMD Ryzen 5 2600 Six-Core Processor (12 Threads)

### Issue description

I apologize in advance for the wall of text, you will lose 10 minutes of your life to even understand what's going on.
Context: I was making an online fully turn-based tactical card game (no timers)

Over the past months I have noticed some packet losses here and there, on **reliable** RPCs. This is a critical bug because it causes a desync I cannot catch (or must make a bloated wrapper to detect desyncs and resync, hence wasting months of work). Yet, these packet drops were not rare as they happened on less than 4 minutes of gameplay to get 1 packet loss (1 move desynced ggwp), as displayed in the screen recordings below.

So, the server sends an RPC to a client, but the message never arrives to client and ofc a desync between server and client(s) is achieved. I would love to debug it but the 2 debugging methods ([console log printing](https://github.com/godotengine/godot/issues/79482) + [watchdog variables](https://github.com/godotengine/godot/issues/79246)) are both bugged and I am also a pleb at wireshark.

Now, I tried to strip down my project heavily to get it to MRP form, I did my best, and focused exclusively on the scenario of the very start of the game, where enemy deck shows his second deck to the other player, where the cards are placed on the appropriate deck slot. (i apologize for the boring context, but its required for the screen recording of the bug)

The annoying thing and why I am writing this wall of text is that this bug's MRP is not deterministic. It just happens once in around 40 use-cases with this MRP, so I doubt anyone will figure out the root of the problem, but with the following screen recordings, its **at least proven that packets do get dropped on reliable RPCs**. 
[See start and skip to 2:40](https://files.catbox.moe/mpr0do.mkv)
[Skip to 3:21](https://files.catbox.moe/07q5jv.mkv)
(The print messages shown^ are out of order because of [another bug with RPCs](https://github.com/godotengine/godot/issues/79482))

Ideally, I would have provided an MRP or use-case scenario where I automate RPCs via timer and basically count how many were sent from the client, and arrived to server, but I thought of this too late, and did it all by hand.

Note that I am using localhost, [without any packet jumbler of sorts](https://github.com/jagt/clumsy) so it makes no sense packets drop. Ofc, I have also tested on a real network via UPNP/Port Forwarding, and packets drop there too.

### Steps to reproduce

See both videos above, and also endure that you have to run the below scenario around 40 times to get a visible packet loss. Spam F5/F8.

1. Debug -> Run 3 Instances
2. Host with one of the instances and ignore this window
3. Join with player1
4. Join with player2 

At this step, the old player must have the cards of the second deck **of the opponent** on the board. If the slot where these cards go is empty, then that's a packet loss as displayed via the print messages.

### Minimal reproduction project

[somewhat-rare-packet-loss.zip](https://github.com/godotengine/godot/files/12053767/somewhat-rare-packet-loss.zip)

ERR_FAIL_COND_V_MSG(!_is_active(), ERR_UNCONFIGURED, "The multiplayer instance isn't currently active.");
	ERR_FAIL_COND_V_MSG(connection_status != CONNECTION_CONNECTED, ERR_UNCONFIGURED, "The multiplayer instance isn't currently connected to any server or client.");
	ERR_FAIL_COND_V_MSG(target_peer != 0 && !peers.has(ABS(target_peer)), ERR_INVALID_PARAMETER, vformat("Invalid target peer: %d", target_peer));
	ERR_FAIL_COND_V(active_mode == MODE_CLIENT && !peers.has(1), ERR_BUG);
	int packet_flags = 0;
	int channel = SYSCH_RELIABLE;
	int tr_channel = get_transfer_channel();
	if (tr_channel > 0) {
		channel = SYSCH_MAX + tr_channel - 1;
	} else {
		switch (get_transfer_mode()) {
			case TRANSFER_MODE_UNRELIABLE: {
				packet_flags = ENET_PACKET_FLAG_UNSEQUENCED | ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT;
				channel = SYSCH_UNRELIABLE;
			} break;
			case TRANSFER_MODE_UNRELIABLE_ORDERED: {
				packet_flags = ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT;
				channel = SYSCH_UNRELIABLE;
			} break;
			case TRANSFER_MODE_RELIABLE: {
				packet_flags = ENET_PACKET_FLAG_RELIABLE;
				channel = SYSCH_RELIABLE;
			} break;
		}
	}
#ifdef DEBUG_ENABLED
	if ((packet_flags & ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT) && p_buffer_size > ENET_HOST_DEFAULT_MTU) {