Combining resources is one way to potentially improve performance for a web site. Let's look, though, at what happens when we take this to the extreme hypothetical you pose.
We can Base64 encode images and put them directly into an HTML document. The first problem, though, is that Base64 encoding a binary object increases its size by a factor of 33%. By doing this, we actually produce larger files to download, which can easily outweigh any savings from eliminating requests.
If we put everything into a single file, we've coupled together any changes to that file. That means that if the HTML file changes, that file and all of the assets in it will also need to be downloaded again. The same is true for changes to any of the other assets. If the files are separate, they get cached separately, and only the files that change need to be downloaded again. (HTTP provides all the necessary mechanisms for this.)
Putting everything into a single file prevents reusing cached resources on other pages. Say we have a home page and an about page with the same stylesheet. With multiple resources, that stylesheet need only be downloaded when we visit one, then the cached version can be used when we visit the other. If everything is embedded directly into every file, the same CSS gets downloaded over and over again for each page.
Parallel downloads and pipelining
In HTTP/1.0, browser developers realized that downloading all assets serially would cause page load to be slow as assets would only load one after the other. In response, browser developers wrote in features to allow multiple connections so that assets could be downloaded in parallel, then all rendered together. This provided some speed up.
HTTP 1.1 introduced many new tools for optimizing performance. Among them was the introduction of pipelining. Instead of waiting for a response to finish, then sending the next request, browsers could take advantage of the full-duplex nature of TCP connections and send the next request as soon as it realized it had to. This allowed assets to be downloaded without delays between, speeding up performance as well.
With your single-page model, browsers would not be able to take advantage of parallel connections to download different assets at once. This could make your page load slower. With the introduction of pipelining, HTTP allows us to offer a similar effect as downloading a single file without interruption.
While combining some files does make sense when measured in real-life situations, combining every file could actually backfire.