Joe Groff, a programmer who writes on graphics, compilers, and language design, including a well-known modern OpenGL tutorial.
HN commenters recommend his multi-part introduction to modern OpenGL as an excellent primer, with one calling it the best guide and another using it for teaching.
Frankly, complaining that developing for Direct3D requires just the DirectX SDK, and that developing for OpenGL requires some combination of other libraries is a stupid complaint. It's the kind of complaint that only complete newbies might have - anyone with any idea about what they're doing will not have a problem with it.
Not that it's hard, anyway. You don't need any actual libraries to use OpenGL. You just need up-to-date headers, and a way to link to the system's OpenGL library. The easiest way to get those is to use an extension loading library, which provides those headers, links to OpenGL at run-time (same thing that Direct3D does) and makes all of the available extensions available automatically.
Complaining about libraries like GLUT, GLFW, or SDL is completely irrelevant. If you were using Direct3D, you'd be writing windowing code directly on top of the Win32 API, which you can still do with OpenGL. If you want to use one of these libraries to handle the platform-specific windowing and OpenGL setup, you can. You don't have to - even in portable games, you can still just write your own platform-specific windowing and OpenGL setup code.
So the development setup and libraries are different. So what? It's fairly simple to work out for anyone but a complete beginner. On platforms like iOS or Mac OS X, OpenGL is actually trivial - everything you need is included in the platform's SDK. Same with Android. Same, to an extent, with Linux. OpenGL is only really awkward on…
I wouldn't dive into Rust right now if you're trying to get into game development at the same time - leave that for when you're a bit more used to general game dev.
Using Lua inside a development environment/engine could be a good start - there's a couple of Lua-based development frameworks that might be worth checking out. Start with 2D games as they're much simpler to get going with and get used to how a game engine will look.
After that, it depends what you want to do. If you mostly want to create some interesting games and care more about the gameplay design side, using a pre-existing engine/framework is best. If you are interested in the development and high-performance side of things as I am, then learn C (not C++) and OpenGL. This is not as hard as it might seem. The best OpenGL tutorial I have found is http://duriansoftware.com/joe/An-intro-to-modern-OpenGL.-Chapter-1:-The-Graphics-Pipeline.html - this will get you writing graphics code from scratch and starting to understand what is going on. You don't need to become a graphics expert, but actually understanding how this side of things works will be invaluable.
If you have questions, my email is in my profile and I can be reached there. Happy to answer individual queries. I'm not currently working in the Games Industry (day job is Scala in Finance) but my side project of the last 2 years is a cross platform engine + game written in C and Lua.
I'd say learning OpenGL would be a good thing. The OpenGL ES 2.0 spec is supported on both iOS and Android and you can write in C++ for both. It might be more practical use some engine, but if you want to understand what is happening under the covers then this is the best way to do it. Plus, shaders are really powerful.
Hope that helps!
Edit: Here's a tutorial that I've been going through myself recently. It's taught on a desktop but everything is applicable to mobile as well.
http://duriansoftware.com/joe/An-intro-to-modern-OpenGL.-Table-of-Contents.html
I'm afraid there isn't a single best place. What is important first is to learn how GPU architecture is different from traditional before you start learning Cuda or linear algebra. Take a look at these sources for absolute beginners.
https://thebookofshaders.com/
http://duriansoftware.com/joe/An-intro-to-modern-OpenGL.-Table-of-Contents.html
http://learnopengl.com/
edit: also when you are ready to pick a language and start writing code, i advise using the universal OpenGL over Cuda.
The main point here seems to be that you can make separate windows with SDL 1.3 and attach OpenGL contexts to them, versus SDL 1.2's approach of single-window-single-OpenGL-context.
As far as OpenGL tutorials go, I recommend "An intro to modern OpenGL" articles by Joe Groff [1]. It covers the things in OpenGL 2 that still exist in OpenGL ES 2.
[1]: http://duriansoftware.com/joe/An-intro-to-modern-OpenGL.-Table-of-Contents.html
One of the best intros I've seen:
http://duriansoftware.com/joe/An-intro-to-modern-OpenGL.-Table-of-Contents.html
Also:
http://oreilly.com/catalog/9780596804831
And then personally I've found this to be the clearest theory:
http://www.amazon.com/Computer-Graphics-Principles-Practice-2nd/dp/0201848406