Is it right to think of a Javascript Function Expression that uses the ‘new’ keyword as ‘static’

No, it is not static because it still has a constructor property pointing to your “anonymous” function. In your example, you could use

var gameData2 = new (gameData.constructor)();

to reinstantiate a second object, so the “class” (instance actually) is not really “static”. You are basically leaking the constructor, and possibly the data that is bound to it. Also, a useless prototype object (gameData.constructor.prototype) does get created and is inserted in the prototype chain of gameData, which is not what you want.

Instead, you might use

• a single, simple object literal (as in Daff’s answer). That means you don’t have a constructor, no closure-scoped private variables (you have used none anyway) and no (custom) prototype.
• the (revealing) module pattern (as in jAndy’s answer). There you’d have an IIFE to create closure-scoped variables, and can return any kind of object.
• an actual constructor (“class”) that can be instantiated later (when needed), and yields the same singleton object always.

This is what the singleton pattern would look like:

function GameData() {
    if (this.constructor.singleton)
        return this.constructor.singleton;
    else
        this.constructor.singleton = this;

    // init:
    // * private vars
    // * public properties
    // ...
}
GameData.prototype.storageAvailable = function () {
    if (typeof (Storage) !== "undefined") {
        return true;
    }
    else {
        return false;
    }
};

var gameData = new GameData();
var gameData2 = new GameData();
gameData === gameData2 === GameData.singleton; // true

Yet, the prototype is quite useless because you have only one instance of GameData. It would only get interesting with inheritance.