Q:

Level vs edge triggering, usefulness of level triggering

Many processors / µCs / dev-platforms (BeagleBoard, Arduino,...) use interrupts.
These can be triggered by the detection of:

HIGH level
RISING edge
CHANGING level (either FALLING or RISING edge)
FALLING edge
LOW level

Now either of two things must be true:  

FALLING and LOW (/ RISING and HIGH) are virtually the same
When a LOW (/HIGH) level is applied over a non-trivial time, the controller is stuck repeating the interrupt service routine over and over  

Both of these don't make sense to me:
The first cannot be true, since it would be totally useless to make the difference in the first place then.
So if the second one is true: how could this be useful? What application is there that is not better off with a combination of RISING and FALLING instead of HIGH?  
Research so far:

This question is just a stub, so it didn't help: https://electronics.stackexchange.com/questions/92833/what-is-the-difference-between-level-triggering-and-edge-triggering
This one is also not too useful as it is about when those interrupts are triggered, not the implications of the differences: What does edge triggered and level triggered mean?
This one mainly elaborates on the differences in detection of the different trigger events: Why edge triggering is preferred over level triggering?

A:

As an addition to the other answers, another look from a practical perspective:
The level triggered interrupt is an indication that a device needs attention. As long as it needs attention, the line is asserted. A device may want the master to clock data out of the devices buffer. It may need immediate attention to prevent buffer overflow (so using interrupt is a good choice vs polling) but it wouldn't be practical if the device has to keep switching edges while the buffer still contains data. The master does its processing as fast as possible, clears the interrupt flag when ready and immediately recognizes that there is more to do.
Edge triggered interrupt is an event notification. When some particular thing happens, the device generates a pulse on the interrupt line and its done (fire and forget). The master just takes notice of it and goes on.
My point is, there is practical use for both.

A:

Edge sensitive interrupt only fires when it detects appropriate edge. That means, only single interrupt will happen. If interrupt is enabled AFTER transition it will not react and message ia lost. Usable when certain event must be captured.
Level sensitive interrupt will happen whenever it will be enabled and appropriate level present. Thus request will be serviced even if interrupt is enabled some time later. Furthermore, multiple devices can be attached to single interrupt line. Usable when state or condition is important.
Your nr. 2 statement is correct. Either interrupt must be disabled or level cause serviced.
In other words, you use edge sensitive when you are waiting for something and level sensitive when something might be already waiting for you.

A:

Level triggered (high or low) can allow the source to say "nevermind" or to keep the trigger active until the ISR gets around to it.  Interrupt latency is not guaranteed on a single core with multiple triggers, though it's usually pretty fast.  Generally, the signal for a level-triggered interrupt is itself edge-triggered and you have to clear it in the ISR or else you'll come right back into it again.
As Ignacio said, level triggered can also do something continuously while active, though you should write your software to not get stuck in an "interrupt loop".  Not getting to your main code can be somewhat difficult to debug.
Edge triggered is good for things that happen once on some event.  If the event happens again, then your response will happen again, so you'll need to be careful about repeated events like switch bounce.

