Welcome to Spine!

1) Yes, you can export to a sequence of PNG files. Obviously you lose some benefits of skeletal animation this way: smaller files, smoother animations, dynamic bone manipulation, etc.

2) Spine is designed specifically for skeletal animation in games and other software. It has runtimes to integrate into your software to render your skeletons. In general, other programs may provide nice features for animating, but aren't designed to make it easy to bring it all into your software. The entire workflow is important and creating the animations is just a part of it. Spine's focus means it solves this particular problem especially well. On the flip side, Spine may not have as many features as some alternatives for more general animating, such as full length cartoons.

Besides that, Spine is a bit of a boutique application in that the entire UI is built from scratch. All of the rendering is custom, from pressing a button to scrolling in the dopesheet. This gives us fine grained control over exactly how everything works. We've spent a lot of effort on details to make it intuitive and easy to use. One example is that selection is done naturally, there is no dedicated selection tool. Instead, you click or drag and it's intelligent enough to give you what you want. Another example is that the tools don't generally require you to click or drag on small handles, instead you can drag anywhere for manipulation. Also you might notice we don't use right click context menus anywhere in the application. These quickly become a junk drawer, hiding functionality and making the app harder to learn.

The best way to compare apps is to try each. Make the same thing from start to finish in each app, including any runtime integration, if required. This is likely to highlight frustrations you'll encounter with a larger project. Also consider how easy or hard it is to edit your animations after they are done, since a lot of animating involves iteration.

All the official Spine runtimes provide similar basic functionality: load, manipulate, render, and some playback convenience via the AnimationState class. Some runtimes have more on top of that which is further integration for a specific game toolkit. The Spine runtime for Unity has the most advanced further integration.

Using spine-unity's SkeletonUtility, you can have the bones in the Spine skeleton drive Unity GameObjects (this is called "follow"). Eg, you can attach a Unity particle emitter to a bone. Alternatively, you can have GameObjects drive bones (called "override"). Eg, you can have a GameObject affected by Unity physics drive the position and rotation of a bone in your skeleton. You could use this for a cape or maybe things hanging off a belt. You'd have bones for these, but wouldn't animate them in Spine, then in Unity you'd set up a physics hinged chain to drive the bones. With a decent amount of fiddling, the result could be that the cape moves around appropriately as the character moves. There are other useful scripts included, such as one for ground constraints. This does ray casting downward and moves a bone upward so it doesn't penetrate the floor. See the platformer example, run it and move the hero to the stairs and you'll notice he bends his knee via IK to avoid his feet going through the floor. There is also a raptor example with ground constraints.

All of this can be done in any runtime, but the provided scripts may provide you a head start. Working with Unity is different than most game toolkits (as is GM), so it may take a good amount of learning. This time cost may not be the best idea, depending on whether your goals are to ship a game or to learn more tech, especially if you already have progress. Generally to maximize productivity you should choose the tools you are most familiar and productive with. I personally prefer non-WYSIWYG game toolkits, with libgdx being my weapon of choice. NB, I'm a libgdx author and Spine is written with libgdx.

PRO does have cool features, but ESS can still take you quite far. ESS doesn't have meshes, deformation, or weights so doing squash and stretch requires some creativity. Now that Spine has the Shear tool, ESS has an easier time with that by using shear and scale (I don't know the status of shear support in GM). For an example of what you can do with ESS even without shear, see Super Spineboy (which also serves as a libgdx example of a full game, with nice MVC source):
https://github.com/EsotericSoftware/spine-superspineboy