So I can include a copy of the license in my non GPL code to unfaithfully implies (or by stupidly believing) my GPL incompatible code is GPL'ed,
No, that's nonsense. The moment you slap GPL on top of your code it becomes covered by GPL. Period. The only situation when your code is GPL-incompatible is when your code incorporates someone else's code which is licensed in a manner which is incompatible with GPL, i.e. covered by 4-clause BSD license.
but since FSF didn't restricted the distribution of the file, they can not pursue me for that.
Yes.
So I fail to understand why Microsoft could sues me if I claim my product iis Microsoft EULA licensed without meeting Microsoft's criteria to do so ($$$$$), but FSF could not do the same if I claim my work is GPL licensed but do not meet the GPL demands.
Because what you are saying is an absolute nonsense.
License is a contract between a copyright holder (licensor) and an user (licensee). It's all it is.
Your confusion stems from the fact that FSF has released a certain boilerplate contract (i.e. GPL) and claims copyright
on the text of the contract itself. But all the FSF copyright on GPL changes is that you are not allowed to edit the license text (i.e. change contract terms). That's all. However, as far as the relationship between the licensor and licensee is concerned, it does not matter where the contract comes from, it matters what the contract says, and what is its legal context.
W.r.t. dynamic linking, the issue is that FSF
claims that their boilerplate contract (GPL) forbids licensee from dynamic linking the GPL code to Orbiter core. However:
(1) the contract does not actually say that! FSF's interpretation is built on a very shaky legal ground (Basically it assumes that API is copyrightable, which is not the case at least in EU.)
(2) since you have given the licensee the code under this contract
with the explicit intent that the code should be used with Orbiter, then, by virtue of legal principles such as
Volenti non fit injuria and
estoppel you have granted the licensee a
de facto license exception for linking with Orbiter core, even if the contract forbids that
per se.
(3) it is good practice that such
de facto exceptions should be spelled
de iure in the copyright notice
The only situation when anyone gets in trouble if the following scenario: you take FSF's code (becoming its licensee) and link this code to Orbiter thus introducing a
de facto license exception -- and give the code to me under the altered license (either
de facto or
de iure). This is equivalent to changing the license terms on FSF's code, which the contract (GPL) between the FSF and you does not allow -- and this is exactly what FSF could sue you for.
However, for your own code the issue is completely moot, because you, as the licensor, can set any terms you like.
What would happen if you released your own add-on under the terms of MS EULA? Not much, the licensee would be bound by different terms of contract. Next, if you somehow managed to release your own code under the terms of MS EULA without fulfilling licensor's obligations specified in this contract then the licensee (i.e. the user) could sue you for breach of contract. That's all.
However, that does not even seem to be possible, because software licenses are one-sided contracts -- i.e. they specify the obligations of the
licensee, not of the
licensor -- the latter is ususally not obliged to anything.
It logically follows that you can only violate software licence when you are in the
licensee position, never in the
licensor position. So to be sued by FSF you would have to first enter the
licensee position with respect to them -- i.e. put their code in your add-on.