If I write a game engine that uses OpenGL 1.5 (not assuming what else I do), is it portable now and is it still portable five years from now or are/will support for OpenGL by hardware and drivers (be) exclusive to their (much more farther along) target OpenGL versions?
Currently, all of the features provided by any OpenGL version x <= 3.0 are explicitly supported by all versions y such as x <= y <= 3.0, and they (old features) can be enabled in versions >= 3.0 by creating compatibility context and accessing those features through the context.
For example, OpenGL 3.0 includes essentially every feature provided by previous OpenGL versions (some being marked as deprecated) - but you can request OpenGL 1.5 compatibility context from a GPU driver supporting e.g. OpenGL 4.0 natively and use those features (fixed-function pipeline comes to mind).
Also, all the major software vendors (AMD/ATI, nVidia, Intel) provide support to legacy OpenGL features in their newest drivers, though the efficiency is often very low, as they are currently unimplemented in hardware, so software emulation is used instead (nb those drivers quite often use code from Mesa project AFAIR); selection mode, old-style (pre-shader) lighting, automagic mipmap generation, display lists and similar features can be considered as such "potentially unsafe" features (though some of them are still quite fast in some cases, as with display lists for example).
tl;dr - yes, it's portable, and probably will be portable, unless driver vendors suddenly feel the urge to cut the connection with the past (not likely, until now it hasn't happened in case of OpenGL) or some new technology makes old features incompatible (likely, but not in the nearest future). A good example is x86 line - until x86-64, it was almost completely backwards-compatible; with introduction of x86-64, the compatibility was broken and some old apps just wouldn't run anymore.
Lately I've been looking at a lot of answers on this website that direct users to divert their work towards the most recent OpenGL versions, citing hardware surveys of DirectX support and only recommending earlier versions as a last, final resort (as if to imply there is something wrong with them that makes all usage of them invalid or pointless).
I'd say that, if you're using shaders (OpenGL >= 3.0, core profile), the difference is actually only minuscule (new features, allowing better gfx quality). The main difference is between fixed-function pipeline and using shaders - because the gap is huge and old code is basically not portable to the new architecture. DirectX is a different beast - you need to install DirectX 9 even if you have DirectX 11 just to use DirectX 9 features (e.g. Direct3D 9) - it makes complete sense to just skip to new DirectX version to avoid the trouble, both for yourself and the application user.
As far as OpenGL goes - if you want your code runnable on pre-shader GPUs, use e.g. OpenGL 2.1 - it's almost 10 years old already, so basically everything supports it. There isn't anything wrong with that, it's just that you won't be able to extend your code to use shaders etc. without much effort (unless your app is already using vertex memory buffers, i.e. vertex arrays - then it's much easier to port).
tl;dr - no, there's nothing wrong with using old OpenGL versions, as long as you're aware that the limitations of pre-3.0 versions can be severe (no "plug-n-play cool water effects" etc).
If I only have computers that can provide OpenGL <=1.5 or <=2.1 contexts should I just give up game programming if I can't afford a new computer with hardware and drivers for 3.x and 4.x? Or should I finish my game engine the way I intended to?
Give up programming? If you're already more than 50% into it - certainly not. Otherwise, I'd reconsider. Anyway, it'd be good for to to avoid all immediate mode calls and move to glDrawArrays etc, since it is essentially nr 1 of what is needed to shade a geometry - storing the data in a vertex array.
Will by the time I get a 4.x supporting setup will there be new versions and a lack of backwards compatibility that trash all usage of 4.x? Will 4.x ever dominate over earlier versions support wise before a new major version is realized and released?
Nobody can tell that for sure. As already stated above, it's quite unlikely, since backward-compatibility has been largely maintained until now, and, in the worst-case scenario, you can always use a software renderer for old applications -
As a side note: there has been 3D technologies/choices that was expected to thrive (IRIS GL, OpenGL++, DirectX/OpenGL fusion (Fahrenheit project), Glide, GLU, 3dfx GPUs, ARB being the only OpenGL governing body, hardware T&L [it got obsoleted/incorporated into shading model]), while some were expected to fail (DirectX first, due to lack of game/application vendor support, being not portabile to non-Windows systems and existence of Glide, OpenGL then due to... lack of game/application vendor support, being not portable to Windows systems [see Windows 2000/Vista problems with OpenGL! making OpenGL API a redirect to Direct3D calls didn't help, either...], Longs Peak controversy, being governed by ARB and existence of Direct3D [see the pattern?], texture compression was expected to be obsoleted due to increasing memory sizes [it's still used commonly, because texture sizes grow faster than memory sizes],
ATI GPUs were considered obsolete by some and expected to die out the same way 3dfx did [but then, suddenly, AMD gave them a hand]) etc etc etc
Also, as far as the very OpenGL API goes (esp. at the times of the all-powerful ARB), there were numerous vendor extensions that have been expected to be incorporated into mainstream API - and they either hadn't been for a long time or not at all, and there were some that appeared with no apparent reason, were seldom used and quickly forgotten - yet nobody exactly knew - why? ...
None of those "prophecies" came true, although some people would literally kill other just to prove they're right about them. Some delusional individuals still spread the FUD around, saying "this technology will die!" and/or "that technology will thrive!" - but that's just that, speculations and opinions.
tl;dr - you can't predict future. Don't ask speculative questions about the future - nobody can answer a question about the future of technology with much certainty; if it was possible, well, the world would be a different place now (we'd probably still have like 10 computers in the world per IBM prophecy, and we'd not even use phones, as they were considered "a mere fad" in the Bell's days...). You can only speculate - and science shouldn't be based on speculation. Don't choose your technology back/front-end based on speculation. Either use old stuff for compatibility, or new stuff for possibilities - you can't have both at the same time. Either stick with what you know and what you can do already, because it allows you to do what you want already, or go forward to learn new stuff, to be able to achieve more.
Source: Wikipedia, google, internet, opengl.com, own experience.
Also, related: OpenGL: What are the adoption rates of the various versions (And what's a reasonable version to use)