refactor: make SubProblems an internal class

src/main/java/edu/kit/provideq/toolbox/meta/Problem.java

@@ -12,6 +12,8 @@
 /**
  * A problem encapsulates an input for a given problem type.
  * The problem can be solved using a matching ProblemSolver.
+ * The {@link Problem} class is essentially a state machine allowing different operations like
+ * configuring the input and solver, and starting or stopping the solution process.
  *
  * @param <InputT> the data type of the problem's input.
  * @param <ResultT> the data type of the problem's solution.
@@ -38,6 +40,7 @@ public Problem(ProblemType<InputT, ResultT> type) {
 
     this.observers = new HashSet<>();
 
+    // Sub-routine management and sub-routine-call handling are outsourced to the SubProblems class
     Consumer<Problem<?, ?>> notifyAdded = addedSubProblem -> this.observers.forEach(
         observer -> observer.onSubProblemAdded(this, addedSubProblem));
     Consumer<Problem<?, ?>> notifyRemoved = removedSubProblem -> this.observers.forEach(

src/main/java/edu/kit/provideq/toolbox/meta/SubProblems.java

@@ -10,9 +10,18 @@
 import reactor.core.publisher.Mono;
 
 /**
- * This class manages the mapping from sub-routine calls to problems.
+ * This internal class manages sub-problems and sub-routine calls of a {@link Problem}.
+ *
+ * @apiNote This class is neither intended to be used by other classes than {@link Problem} nor to
+ *     be extended or replaced.
+ * @implNote {@link SubProblems} is separate to {@link Problem} as it deals with another level of
+ *     abstraction.
+ *     {@link Problem} is essentially a state machine for the solution process of a problem and
+ *     {@link SubProblems} deals with the type-safe wiring between sub-routines and sub-problems.
+ *     Additionally, having {@link SubProblems} implement the {@link SubRoutineResolver} interface
+ *     avoids interface pollution in the {@link Problem} class.
  */
-public class SubProblems<InputT, ResultT>
+final class SubProblems<InputT, ResultT>
     implements SubRoutineResolver, ProblemObserver<InputT, ResultT> {
 
   private static class SubProblemEntry<SubInputT, SubResultT> {