In the beginning there was light
OpenGL lighting, to be specific, which specified certain mathematical operations to be applied to a fragment, which were then combined with textures to derive a final colour.
And then there was Quake
Quake didn't use this kind of lighting for many of it's objects. Instead it used a second texture to represent lighting, which was multipled by (or "modulated with) the object texture to derive a final colour.
However, hardware of the time didn't support this in a single operation. So Quake needed to draw it's scene objects twice:
- Draw everything once to lay down the base textures.
- Set a modulate blend mode.
- Draw everything a second time to apply the lighting textures.
This of course was slow; not only did all geometry need to be transformed and clipped twice (which in those days was a CPU operation), but every pixel on-screen ended up being touched twice during rendering.
Multitexture was the solution to this, and was originally exposed via the GL_SGIS_multitexture extension, which only existed on certain consumer 3DFX cards. Originally it only allowed blending two textures (and with a limited set of blend modes).
To quote from the original GLQuake readme:
Multitextures support allows certain hardware to render the world in one pass instead of two. GLQuake uses two passes, one for the world textures and the second for the lightmaps that are blended on the textures. On some hardware, with a GL_SIGS_multitexture supported OpenGL implementation, this can be done in one pass. On hardware that supports this, you will get a 60% to 100% increase in frame rate. Currently, only 3DFX dual TMU cards (such as the Obsidian 2220) support this extension, but other hardware will soon follow.
It's important to remember that at this time effects such as normal mapping, any other kind of per-pixel lighting, even shaders, and so on just didn't exist (well they did, but primarily just in academic papers and research projects, and weren't considered viable for use in real-time rendering).
And so to the present
From here it's pretty much as described in the other answers. Multitexturing became a standard feature over time, with more blend modes becoming available, eventually giving way to arbitrary shader code.
But what's important for the purposes of your question is this: in the beginning the standard functionality was just being able to use one texture at a time when rendering. Being able to use more than one was additional functionality that only high-end hardware supported, and so it needed a name. That name could have been "dual-texturing" (as the first implementations just supported two textures) but with one eye on the future the name "multitexture" was chosen.
Further reading on the history of all this is available here, and a good historical writeup (of the broader context, and the part multitexturing played in it) at this Programmers.SE answer.