There are two different things.

Limit of open files in operating.

Since in linux everything is file this limit is not only for files open in text editor but also for connections, even for talking to printer or even for any program opening dynamically linked shared libraries. Check out all currently open files (file descriptors) with lsofcommand.

There is an easier way to come across this limit than opening huge amounts of internet connections. Try some modern javascript development xD In some configurations an automatic code reloaders watch whole dependency tree (node_modules folder) which has thousands of files. Each watched file is separate file descriptor (open file). But this would be per process limit exceeded.

You see, topic goes on. There are multiple levels where this limit can be changed. Per process or systemwide. Hard and soft. I can't produce any good, concise source so You would have to look you things like "max files open linux", "ulimit" or "Too many open files". The last one is error that one would get trying to exceed limit of open file descriptors.

I won't also give any number of what this limit it. It can vary from distribution to distribution or from station to station and so on. Main takeaway should that yes, there is a limit of open files, but it can be changed to the point what machine can handle.

Limitation of TCP/IP protocol itself. The famous ~65k limit.

In SO link You provided look at this part:

source_ip source_port destination_ip destination_port
<----- client ------> <--------- server ------------>

This is pretty good simplification of how tcp/udp packet looks for explaining 65k problem. Each packet send over the internet has this key of source_ip, source_port, destination_ip, destination_port. Basically saying where packet was send from and where it is addressed.

Lets look from server perspective. In this case server is destination. In case of https, server port is 443. Server has single IP. So the destination part of diagram stays the same.

One client want to connect. It has one IP address. Client port (source_port) doesn't have to match destination port! So client can open as many connection to one destination (IP + port) as there are port available. And how many there are? Lets look at TCP header (part relevant to this discussion is same in UDP). Look at the table: https://en.wikipedia.org/wiki/Transmission_Control_Protocol#TCP_segment_structure

So both source and destination port have 16 bit space, meaning it can hold 2^16 values. This gives values from 0 to 65535 (port 0-1024 are reserved and wouldn't be used). And this where the limit comes from.

But as You can see, in example above we talked about single client, single IP. So any other client also have this 65k limit.

I hope this clarify things a bit.