Create base of support for pause

- Create an enum for different run modes that determine whether a coroutine can be paused and when it runs.
- Refactor the CoroutineBase code by adding a new Init() method which internally calls OnEnter(). This allows the virtual OnEnter() method to be empty, so that subclasses need not call the base class implementation.

src/CoRunMode.cs

@@ -0,0 +1,26 @@
+namespace HCoroutines;
+
+/// <summary>
+/// The RunMode determines when the coroutine is run and whether it can be paused.
+/// </summary>
+public enum CoRunMode {
+    /// <summary>
+    /// The RunMode is inherited from the parent coroutine. If there is no parent, Pausable is used.
+    /// </summary>
+    Inherit, 
+
+    /// <summary>
+    /// The coroutine is paused when the game is paused.
+    /// </summary>
+    Pausable, 
+
+    /// <summary>
+    /// The coroutine only runs when the game is paused.
+    /// </summary>
+    WhenPaused, 
+
+    /// <summary>
+    /// The coroutine always runs, regardless of whether the game is paused is or not.
+    /// </summary>
+    Always
+}

src/CoroutineBase.cs

@@ -27,27 +27,44 @@ public class CoroutineBase
     /// Determines whether the Update() method is called during process frames or physics frames.
     /// </summary>
     public CoProcessMode ProcessMode { get; private set; }
-
+
+    /// <summary>
+    /// Determines the pause behaviour of this coroutine.
+    /// </summary>
+    public CoRunMode RunMode { get; private set; }
+
     public void StartCoroutine(CoroutineBase coroutine)
     {
         coroutine.Manager = Manager;
         coroutine.Parent = this;
 
         AddChild(coroutine);
-        coroutine.OnEnter();
+        coroutine.Init();
     }
 
     /// <summary>
-    /// Called when the coroutine starts.
+    /// Initializes the coroutine once it has been added to the active coroutine hierarchy.
     /// </summary>
-    public virtual void OnEnter()
+    public void Init()
     {
         if (this.ProcessMode == CoProcessMode.Inherit) 
         {
             this.ProcessMode = Parent?.ProcessMode ?? CoProcessMode.Normal;
-        }    
+        }
+
+        if (this.RunMode == CoRunMode.Inherit)
+        {
+            this.RunMode = Parent?.RunMode ?? CoRunMode.Pausable;
+        }
+
+        OnEnter();
     }
 
+    /// <summary>
+    /// Called when the coroutine starts.
+    /// </summary>
+    public virtual void OnEnter() { }
+
     /// <summary>
     /// Called every frame if the coroutine is playing.
     /// </summary>

src/CoroutineManager.cs

@@ -20,7 +20,7 @@ public partial class CoroutineManager : Node
     public void StartCoroutine(CoroutineBase coroutine)
     {
         coroutine.Manager = this;
-        coroutine.OnEnter();
+        coroutine.Init();
     }
 
     public void ActivateCoroutine(CoroutineBase coroutine)