@Itms we, 1. use a forward declaration for a class if we don't reference private members or other declaration of the header file,

2. use the header file when we don't want to repeat many declarations of the headerfile
3. never avoid an include or forward declaration if a different file happens to provide the declarations (such as ScriptFunctions.cpp here), right? Otherwise this line could be deleted entirely.

A forward declaration is enough if the header only contains pointers and references to instances of the class

That seems incorret / incomplete:
If there is class ScriptInterface; in JSInterface_ModIo.h without include, then we get
../../../source/ps/scripting/JSInterface_ModIo.h:30:50: error: ‘pCxPrivate’ was not declared in this scope
so why would we do this here differently?

Hm then why does JSInterface_Console.h currently works? As far as I can see it only has a forward declaration and pointers to ScriptInterface::CxPrivate. It rather sounds like the cpp file that includes JSInterface_ModIo.h is missing the scriptinterface/ScriptInterface.h include.

JSInterface_Console.h is included in three places and at least one (GameSetup.cpp) includes it prior the ScriptInterface to keep alphabetic ordering according to the coding conventions, which is an example on why it is good practice to serve declarations in header files, right?

I'm sorry I don't see your point... You know that forward declarations are here so that we can put includes in any order, right? And I don't know what you mean by "serv[ing] declarations in header files".
Yes, that means files are included more often (for instance ScriptInterface.h has to be included in the three cpp files, instead of only JSInterface_Console.h), but that makes maintenance far easier (one doesn't have to follow a long chain of includes to see whether a removal would break something).

In a nutshell, the more includes in .cpp files and the less in .h files, the better.

Is it clearer for you put that way? Do you see the rationale?

I agree with what you state here, but not with the conclusion to keep this line as is.

The line should be either removed entirely because ScriptInterface and ScriptInterface::CxPrivate are both declared prior (it does compile without this line), or we change this to an actual include, so that both ScriptInterface and ScriptInterface::CxPrivate are declared independent of prior declarations.

I would agree to use a forward include here, if we would only have a reference to a ScriptInterface type. But this file also has a declaration of ScriptInterface::CxPrivate which is not declared by the forward include. We can see in the other file that a forward include class ScriptInterface; is insufficient to mark ScriptInterface::CxPrivate as declared (Reproduce by removing the include but keeping the forward declaration in JSInterface_Modio.h and get ../../../source/ps/scripting/JSInterface_ModIo.h:30:50: error: ‘pCxPrivate’ was not declared in this scope). The forward include here is, as is, entirely useless, the line can be removed and it still compiles. It only compiles because something else already happens to include Scriptinterface.h which declares both ScriptInterface and ScriptInterface::CxPrivate.
Compile it and you will see it in action what I mean.

Or let me put it this way,
if you do a filesearch for "class ScriptInterface;" you come across files that do reference ScriptInterface and nothing else (especially not ScriptInterface::CxPrivate),
if you do a filesearch for #include "scriptinterface/ScriptInterface.h", you see files that do reference ScriptInterface::CxPrivate, except the ones changed here and maybe some other unnoticed oversights.

A pointer to an element of the ScriptInterface namespace is covered by a forward declaration of the class.

The compiler error is because JSInterface_ModIo.cpp (CPP) should have #include "scriptinterface/ScriptInterface.h". I'm sorry I can't compile that, I'm at work. I don't think I need to do it myself though.

The forward declaration might be useless by chance in this specific situation, but it is needed if you want to be free to include headers in any order.

Also, please use correct denomination for things, in order to overcome the misunderstandings: a "forward include" doesn't exist, I don't know if you are referring to a "forward declaration" or a "header include".

Answering the filesearch comment: yes, indeed, we are doing it wrong currently. It builds but it is more difficult to maintain. Your current patch goes from 90% going against the conventions to 100% against. I don't think it's the end of the world if we stay at 90%, but you're not going in the good direction.

Removing the forward declaration would be an actual C++ mistake though, as it would cause future changes to break.