Refactor pic namespace to TimeIntegration class

[Eleven7825]

Problem

Background

The pic namespace currently implements the Generalized α-Method for time integration (Predictor-Initiator-Corrector scheme). However, the name "PIC" is misleading as it's commonly associated with "Particle-In-Cell" methods in computational physics, not time integration schemes.

Related to: Ongoing OOP refactoring effort (see #442)

Current State

Location: Code/Source/solver/pic.h and Code/Source/solver/pic.cpp

The current namespace contains four functions implementing the Predictor-Initiator-Corrector
scheme:

namespace pic {                                                                                    
  void picp(Simulation* simulation);              // Predictor                                     
  void pici(Simulation* simulation, ...);         // Initiator                                     
  void picc(Simulation* simulation);              // Corrector                                     
  void pic_eth(Simulation* simulation);           // Helper for Taylor-Hood elements               
};                                                                                                 
                                                                                                   
Current usage (3 files):                                                                           
- main.cpp:319 - calls pic::picp()                                                                 
- Integrator.cpp:189 - calls pic::pici()                                                           
- Integrator.cpp:331 - calls pic::picc()                         

Solution

Refactor the pic namespace into a TimeIntegration class with clearer, self-documenting method names:

                                                                                                    
 class TimeIntegration {                                                                            
 public:                                                                                            
   /**                                                                                              
    * @brief Predictor step: predict solution at next time step                                     
    *                                                                                               
    * Sets up prediction for next time step using Generalized α-Method.                             
    * Updates An, Yn, Dn arrays.                                                                    
    */                                                                                              
   static void predict(Simulation* simulation);                                                     
                                                                                                    
   /**                                                                                              
    * @brief Initiator step: compute quantities at intermediate time levels                         
    *                                                                                               
    * Computes solution at n+α_m and n+α_f time levels for Generalized α-Method.                    
    *                                                                                               
    * @param Ag Acceleration at intermediate time level                                             
    * @param Yg Velocity at intermediate time level                                                 
    * @param Dg Displacement at intermediate time level                                             
    */                                                                                              
   static void initialize_step(Simulation* simulation,                                              
                               Array<double>& Ag,                                                   
                               Array<double>& Yg,                                                   
                               Array<double>& Dg);                                                  
                                                                                                    
   /**                                                                                              
    * @brief Corrector step: update solution and check convergence                                  
    *                                                                                               
    * Updates solution variables (An, Yn, Dn) and checks convergence criteria.                      
    * Also determines which equation to solve next.                                                 
    */                                                                                              
   static void correct(Simulation* simulation);                                                     
                                                                                                    
 private:                                                                                           
   /**                                                                                              
    * @brief Apply pressure correction for Taylor-Hood elements                                     
    *                                                                                               
    * Interpolates pressure at edge nodes for Taylor-Hood type elements.                            
    */                                                                                              
   static void correct_taylor_hood_pressure(Simulation* simulation);                                
 };                                                                                                 
                                                                                                    
 Call site updates:                                                                                 
 // Before                                                                                          
 pic::picp(simulation);                                                                             
 pic::pici(simulation, Ag, Yg, Dg);                                                                 
 pic::picc(simulation);                                                                             
                                                                                                    
 // After                                                                                           
 TimeIntegration::predict(simulation);                                                              
TimeIntegration::initialize_step(simulation, Ag, Yg, Dg);  
TimeIntegration::correct(simulation);                      

### Additional context

_No response_

### Code of Conduct

- [x] I agree to follow this project's Code of Conduct and Contributing Guidelines

[mrp089]

Are you planning on making An, Yn, Dn, Ao, Yo, Do class variables?
In the future, it would be cool to have an abstract base class for time integration, with different integrators inheriting from that (GenAlpha being one of them). We don't have to do this now, but can already anticipate that in the structure of TimeIntegrator.

[Eleven7825]

I think An, Yn, Dn, Ao, Yo, Do should be class variables of our previous Integrator class(now NonLinearProblem). Maybe Ag, Yg, Dg should be here at the TimeIntegration class because they pic specific?

[Eleven7825]

As I discussed with @mrp089, we want to proceed with following changes:

1. Remove pic.cpp (which contains the pic namespace) completely and move all its functions (picp, pici, picc) into our Integrator class (we might rename the Integrator class).
2. We want to remove A_n, D_n, Y_n, A_o, D_o, Y_o, R, val from the ComMod. Instead, we made them part of member variables of the new Integrator class. This requires us to traced down to where are those variables are used in the functions. For example for An:

grep -r "\.An"
remesh.cpp:  com_mod.An.clear();                                                         
output.cpp:  auto& An = com_mod.An;                                                      
output.cpp:  auto& An = com_mod.An;                                                      
main.cpp:  auto& An = com_mod.An;      // New time derivative of variables               
main.cpp:  auto& An = com_mod.An;      // New time derivative of variables (acceleration)
uris.cpp:  // auto& An = com_mod.An;                                                     
uris.cpp:  // auto& An = com_mod.An;                                                     
pic.cpp:///   com_mod.An                                                                 
pic.cpp:  auto& An = com_mod.An;                                                         
pic.cpp:  const auto& An = com_mod.An;                                                   
pic.cpp:  auto& An = com_mod.An;                                                         
ris.cpp:  auto& An = com_mod.An;                                                         
ris.cpp:        com_mod.Ao = com_mod.An;                                                 
ris.cpp:  auto& An = com_mod.An;                                                         
txt.cpp:              tmpV(i,j) = com_mod.An(i+s,j);                                     
Integrator.cpp:  auto& An = com_mod.An;                                                  
README.md:  com_mod.An.resize(tDof,tnNo);                                                
README.md:  com_mod.An = com_mod.Ao;                                                     
initialize.cpp:///   com_mod.An.resize(tDof,tnNo);                                       
initialize.cpp:///   com_mod.An = com_mod.Ao;                                            
initialize.cpp:  com_mod.An.resize(tDof,tnNo);                                           
initialize.cpp:  com_mod.An = com_mod.Ao;                                                

Instead of passing down ComMod, those variables should be passed down as argument to functions who used them at every level. Since we are only dealing with 8 variables, this is still a managable workload.
3. This will be our first step toward usable code for our growth and remodeling as we want to create two seperate Integrator classes for fluid and solid seperately but most likely just one ComMod class that contains common variables.