Fix the harmful uses of #define private public

[Critsium-xy]

Background

#define private public around an #include appears in 85 files in this tree
(116 occurrences). It is not a harmless test trick: it gives that translation unit
a different definition of the class than the rest of the library it links
against, which is an ODR violation, and it silently applies to every other header
pulled in by the same region.

This PR does not try to remove the pattern everywhere. It fixes the cases where it
was actually doing damage, and gives the most common case a proper mechanism.

What is fixed

1. The one occurrence in production code

source_io/module_output/cal_test.cpp is compiled into the main library
(source/source_io/CMakeLists.txt), not into a test target, and wrapped
parameter.h. The shipped binary therefore contained one translation unit that saw
Parameter::input / Parameter::sys as public while every other one saw them as
private.

The hack was also unnecessary: the file only reads PARAM.inp.nbands and
PARAM.globalv.nlocal, both public.

2. parameter.h is no longer compiled with access control disabled anywhere

It was, in 53 translation units — about a fifth of all wrapped includes.

parameter.h has always declared friend class TestParameters as the sanctioned
way for tests to set parameter values, but that class was never defined anywhere
shared: three test files each defined their own local copy (itself an ODR hazard),
and everyone else reached for the macro instead. This PR defines it once in
source_io/module_parameter/test_parameters.h and routes all 1686 test accesses
through it:

PARAM.input.x     ->  TestParameters::input().x
PARAM.sys.x       ->  TestParameters::sys().x
param.input.x     ->  TestParameters::input(param).x      // local Parameter

parameter.h is now included before the remaining regions rather than inside
them, so its include guard is already satisfied when a region is compiled. That is
what fixes the files which pulled it in transitively via read_input.h or
setcell.h rather than directly.

After this, the only code in the tree touching Parameter::input / Parameter::sys
is its three declared friends: ModuleIO::ReadInput, elecstate::ParamUpdater,
and TestParameters.

3. Seventeen regions that were never closed

Sixteen of these are fixed in place (the seventeenth is the dead file deleted
below). They opened #define private public (usually protected too) and ran to
end of file — up to 1016 lines in charge_mixing_test.cpp. elecstate_pw_test.cpp closed
protected 318 lines later at the end of the file and never closed private at
all.

Each #undef now sits immediately after the include block it is meant to cover. No
include is moved: in every one of these files the standard headers already came
after the project headers, so they simply fall outside the region once it is
closed. That removes the incidental treatment of <omp.h>, <string>,
<fstream>, <mpi.h>, <source_base/macros.h>,
<source_base/module_external/scalapack_connector.h> and "mpi.h".

4. Nine unit tests that reported PASS while asserting nothing

source/source_base/test/CMakeLists.txt:1 already calls
abacus_disable_feature_definitions(__MPI), so __MPI is never defined for that
directory and every #ifdef __MPI in it is always false. Nine test bodies were
wrapped in one, so they were compiled out in every configuration:
opt_cg_test.cpp (5), opt_tn_test.cpp (2), math_chebyshev_test.cpp (2).

Removing the guards exposed why they had been disabled — in an MPI build they
abort with:

*** The MPI_Allreduce() function was called before MPI_INIT was invoked.

The test sources are compiled without __MPI, but they link base, which is built
with it, so Opt_CG reaches Parallel_Reduce::reduce_all (opt_cg.cpp:134 and 10
more). The old #undef __MPI could never have prevented that — the library is a
separate translation unit, already compiled.

• opt_cg / opt_tn (7 tests) now use the mechanism the build system already
  provides for this (cmake/Testing.cmake:38-44, used the same way in
  source_estate/test/CMakeLists.txt:132): the targets keep __MPI, and each file
  gains a main() calling MPI_Init/MPI_Finalize, matching
  math_sphbes_test.cpp in the same directory. All 7 now run and pass with
  their original expected values.
• math_chebyshev.checkconverge / checkconverge_float need POOL_WORLD (via
  GlobalFunc::ddot_real -> Parallel_Reduce::reduce_pool), not just
  MPI_COMM_WORLD. They are byte-identical duplicates of the tests in
  test_parallel/math_cheby_mpi_test.cpp (MODULE_BASE_math_chebyshev_mpi), which
  sets POOL_WORLD up correctly and runs them. They are deleted here rather than
  resurrected — no coverage is lost.

5. Dead code removed

• source_io/test/for_testing_input_conv.h — included by nothing. It was the only
  header applying #define private public, and applied it to 22 module headers at
  once; it also defined non-inline globals at file scope, which would be a
  duplicate symbol the moment a second TU included it.
• source_hsolver/test/test_diago_assist.cpp — in no CMakeLists.txt, includes a
  header that does not exist (diago_iter_assis.h), and has a statement in a class
  body, so it cannot compile. Dead since [Refactor] Rename module_hsolver to source_hsolver #6305.
• Six no-op regions: unitcell_test_setupcell.cpp and unitcell_test_pw.cpp had a
  bare #define private public immediately followed by #undef private;
  write_orb_info_test.cpp, rho_io_test.cpp, deltaspin_pw_test.cpp and the
  second region of bfgs_test.cpp wrapped only parameter.h and never touch a
  private member of Parameter.

Result

	before	after
files with #define private/protected public	85	59
occurrences	116	80
in production code	1	0
in a header	1	0
regions never closed	17	0
TUs compiling parameter.h with access control off	53	0
tests compiled out unnoticed	9	0
system headers compiled inside a region	8	0

What is deliberately left

The remaining 59 files wrap the header of the class under test (unitcell.h,
klist.h, charge.h, sltk_grid.h, ...) to reach its private members. Those
regions are now all balanced, tight, and free of standard headers, but the pattern
is still there. Removing it means giving each of those classes a test seam — a much
larger and more opinionated change, better done per module than in one PR.

read_wf2rho_pw_test.cpp still has a file-level #undef __LCAO before its
includes. That one is load-bearing (it selects the non-LCAO path in the headers
below it) and belongs in the test's CMakeLists as
abacus_disable_feature_definitions(__LCAO), but changing it changes what the test
compiles, so it is left for a separate change.

Review notes

• The bulk of the diff is the mechanical PARAM.input -> TestParameters::input()
  substitution (1686 sites, applied by script, uniform). The interesting commits
  are the 1st, 3rd, 5th, 6th, 7th and 8th.
• Commits are split by concern so they can be reviewed or dropped independently.
• test_parameters.h is header-only, so no CMakeLists.txt change is needed for
  it.
• No new default arguments — the global-PARAM and local-Parameter forms are
  separate overloads.
• agent_governance_check.py --base upstream/develop: no blockers. The
  global-dependency budget moves by -921 (10 added, 931 removed). Remaining
  warnings are the three added header includes (test_parameters.h itself needs
  parameter.h; setcell.h and md_test_fixture.h need the new helper) and "no
  docs change", which is expected: no INPUT parameter, interface or runtime
  behaviour changes outside test code.

Testing

Verified with gcc / Ninja, BUILD_TESTING=ON, in two configurations:

configuration	build
-DENABLE_LCAO=ON -DENABLE_MPI=OFF -DENABLE_OPENMP=ON	clean
-DENABLE_LCAO=ON -DENABLE_MPI=ON -DENABLE_OPENMP=ON	clean

Unit tests, compared against an upstream/develop build in the identical
configuration (ctest -E "^[0-9][0-9]_", serial, OMP_NUM_THREADS=1):

	upstream/develop	this branch
tests run	325	325
failures	31	31

No regressions and no differences at all -- the failing set is byte-identical
on both trees. Those 31 are pre-existing in this environment and are mostly
mpirun-based wrappers or in files this PR never touches (blas_connector,
math_sphbes, cubic_spline, PSI_init, dav, bpcg, the *_para /
*_parallel targets).

(Run under -j4 the count wobbles between 31 and 33 on both trees, because
MODULE_BASE_memory and MODULE_BASE_tool_quit are load-flaky; both pass 5/5
standalone on both trees and neither is touched by this PR. The serial numbers
above are the flake-free comparison.)

The re-enabled tests specifically:

$ ./MODULE_BASE_opt_cg
[       OK ] CG_test.Stand_Solve_LinearEq (3 ms)
[       OK ] CG_test.PR_Solve_LinearEq (0 ms)
[       OK ] CG_test.HZ_Solve_LinearEq (0 ms)
[       OK ] CG_test.PR_Min_Func (0 ms)
[       OK ] CG_test.HZ_Min_Func (0 ms)
[  PASSED  ] 5 tests.

$ ./MODULE_BASE_opt_tn
[       OK ] TN_test.TN_Solve_LinearEq (3 ms)
[       OK ] TN_test.TN_Min_Func (0 ms)
[  PASSED  ] 2 tests.

They pass against the expected values already written in those files — the
assertions had simply never been compiled.

Integration tests (tests/) were not run here; they need the full toolchain build.

[mohanchen]

I don't like this solution.