upgrade ormolu-action with explict ormolu version.

* flake update. remove unused packages
* support ghc962
* ormolu formatting
* additional ormolu formatting
* CI: ghc 9.6.2 as default and update ormolu-action
* update cabal files
* explicit version
* further formatting

The simplest HsProxy is migrated.
For the time being, haskell-src-exts and ghc+ghc-exactprint will coexist and haskell-src-exts will be faded away. 

* prepare for ghc-exactprint migration. use only Util.HaskellSrcExts functions except types.
* explicit export
* make proxy-test generatable (for temporary tests for ghc-exactprint codegen)
* first try to generate code using ghc-exactprint
* finally print as desired.
* success in LANGUAGE pragma printing
* mkImport implementation
* mkFun, mkFunSig
* further mkBind1
* correct indentation doE and handling empty list
* remove all s1
* con, inapp, op, par, strE
* ormolu format fix
* ghc945 -> ghc962 in CI

* simplify imports
* start using ghc-exactprint for HsFFI
* mkForImpCcall
* hsFFIFunType almost implemented. FFI import formatting
* unfortunately, i had to resort to a dirty solution for foreign imports.
* c2HsType, postProcess
* generated HsFFI code works.
* format

Handling typeclass instance declaration with ghc-exactprint.

* refactor out mkDeltaPos and mkEpaDelta
* mkInstance implementation
* migrate HsCast to ghc-exactprint
* correct handling trailing commas.
* generated code is compilable!
* fix parentheses
* ormolu format

Separated out HsRawType out of HsFrontend.
implemented mkData, mkNewtype, mkDeriving etc. so that RawType can be generated and tested.

* separate out HsRawType
* mkData, mkNewtype. HsRawType is almost converted.
* now no missing part in HsRawType
* mkDeriving
* mkTypeFamInst
* generated code formatting correctly. now it works!
* ormolu

to HsCommon, HsInterface, HsImplementation, HsTopLevel

* separate out HsInterface
* separate out HsImplementation
* remove warnings in separated modules
* remove warnings in HsCast
* rename remaining HsFrontEnd to HsTopLevel
* HsCommon module separation
* remove warnings

HsInterface and HsImplementation is fully converted.
Note: template member functions are disabled for now. will be reinstated in the following PRs.

* mkClass
* mkImportSrc
* convert genHsFrontDecl
* converted cxx2HsType, extractArgRetType', functionSignature', tyForall, qualTy
* implemented mkPVarSig, pbind, letE, valBinds, toLocalBinds
* now genHsFrontUpcastClass is converted.
* HsInterface is fully converted
* correct formatting. stdcxx is buildable with generated code!
* mark old code using O, in HsImplementation
* genImportInImplementation converted
* genHsFrontInst converted
* remove the old genExtraImport_ and genImportInCast_
* accessorSignature converted
* converted all functions in HsImplementation
* remove old imports.
* format fix

Moved top-level template codegen to HsTopLevel, TMF codegen to HsImplementation and split HsTemplate to HsTH and HsTemplate.

* move top-level template codegen to HsTopLevel
* move template member functions to HsImplementation
* separate out HsTemplate to HsTemplate and HsTH.

* implement tyTupleBoxed, pTuple, lamE, tupleE, bracketExp, typeBracket
* now genTMFExp is converted modulo functionSignatureTMF'
* implement cxx2hsType4Tmpl (old convertCpp2HS4Tmpl) and functionSignatureTMF
* now genTMFExp is fully implemented.
* finally, TMF function gen is implemented!
* mkBindStmt
* mkLetStmt
* template member function generated code works!
* simple test script. add hspec-discover to the devshell dep

and now only top-level function generations are left.

* HsTemplate!
* convert genTmplImplementation
* TH code gen successful!
* fix further
* remove old functionSignature..

* genImportInModule implemented.
* ethingall, evar, eabs
* top-level exports
* upgrade all imports
* genTopLevelDef. remove old code.
* genTLTemplateInterface
* genTLTemplateImplementation
* Finally! it fully worked with the migrated functions.
* remove haskell-src-exts!
* ormolu format

C/C++ enum is now translated to a Haskell data type.

* introduce CPTEnum case.
* remove old CEnum
* Enum data type generation
* Enum generation is using hsc2hs. --cc=c++ --ld=c++ option
* build fix
* format Enum-generated data type
* introduce DeclGroup
* standalone comment generation (for #include statement)
* Enum instance generation (only succ/pred)
* mkBind
* fromEnum generation!
* remove stale code
* format fix

* missing Castable instance for Ptr CBool
* missing Castable (Ptr CFloat) (Ptr CFloat)

)

Now int to enum type is explicitly casted.
so on Haskell side, enum argument is still CInt, but on C++ side, it's explicitly casted by cast operator: (enum_type)

User should now specify unsafe/safe/interruptible explicitly.
constructors and destructors are always unsafe (this should be taken granted. C++ library should not call Haskell back inside constructor/destructors). Accessor functions (getter/setter) are also unsafe.
On the other hand, calling an instance of std::function (which is hard-coded in FFICXX.Runtime.Function.TH) should be unconditionally safe.

* unsafe testing
* introduce C FFI Safety
* ordinary function safety is handled.
* Safety in fficxx-runtime
* template haskell gen now handles Safety
* Add Safety parameter in TFun. and update stdcxx
* update examples with Safety parameter
* upgrade template TH code generation with FFISafety
* calling std::function should be safe!

The bugs were introduced when migrated from haskell-src-exts to ghc-exactprint.