how to add a function to Leveling a Character useing the Fibonacci sequence?

You don't seem to understand what that formula stands for. It's a "recurrence relation". The "f" in fn = fn-1 + fn-2 doesn't stand for a constant. "fn" stands for a particular number in the sequencem specifically the "nth" number. The fibonacci sequence is a common example for recursion, however it's quite inefficient to use a recursion for calculating the sequence.

 public static int Fib(int aIndex)
 {
     if (aIndex <= 0) // important, breaking condition for the recursion
         return 0;
     if (aIndex == 1) // important, breaking condition for the recursion
         return 1;
     return Fib(aIndex-1) + Fib(aIndex-2); // recursion
 }

This function will return the nth fibonacci number. So if you call

 Fib(10);

it will return "55" the "10th" fibonacci number:

  n      Fib(n)
 ----------
  0  -   0
  1  -   1
  2  -   1
  3  -   2
  4  -   3
  5  -   5
  6  -   8
  7  -  13
  8  -  21
  9  -  34
 10  -  55

As i said calculating the fibonacci sequance recursively is quite inefficient, It's easier to calculate it iterative

 public static int Fib(int aIndex)
 {
     int n1 = 0;
     int n2 = 1;
     for(int i = 1; i < aIndex; i++)
     {
         int tmp = n1 + n2;
         n1 = n2;
         n2 = tmp;
     }
     return n1;
 }

This does the same but without recursion.

In your case instead of storing only "XpToNxtLvl" you could store the last two numbers instead of the last one. So basically when you level up you just do "one iteration" of the for loop yourself to get the next number in the sequence. Of course you could use the "Fib()" method to calculate a certain fibonacci number, but for higher numbers it's unnecessary to count up from the very beginning if you can simply store the last two numbers instead.

edit

Here's a class that automatically builds a lookup table for Fibonacci numbers:

 using UnityEngine;
 using System.Collections.Generic;
 
 public class Fib
 {
     public static Fib Global = new Fib();
     private List<int> m_Numbers = new List<int>();
     public Fib()
     {
         m_Numbers.Add(0);
         m_Numbers.Add(1);
     }
     public int this[int aIndex]
     {
         get { return GetNumber(aIndex); }
     }
 
     public int GetNumber(int aIndex)
     {
         if (aIndex < 0)
             throw new System.ArgumentOutOfRangeException("aIndex must be positive");
         if (aIndex >= m_Numbers.Count)
             GenerateUpTo(aIndex);
         return m_Numbers[aIndex];
     }
 
     private void GenerateUpTo(int aIndex)
     {
         for(int i = m_Numbers.Count; i <= aIndex; i++)
         {
             m_Numbers.Add(m_Numbers[i-2] + m_Numbers[i-1]);
         }
     }
 }

You can create an instance of that class somewhere (and store it for later use) or use the static "Global" instance. Of course the "Global" instance is not thread-safe. To get a certain number you can simply do:

 int xp1 = Fib.Global[8];  // returns 21
 int xp2 = Fib.Global[34];  // returns 5,702,887

Keep in mind that a signed 32 bit integer can only represent the fibonacci numbers up to "level" 46. The 47th number is 2,971,215,073 and a signed integer only goes up to "`2,147,483,647`".

Even when using "ulong" as type (unsigned 64bit integer) you can only go up to fib number 93 which is 12,200,160,415,121,876,738

It depends on how "accurate" you actually need them to be. Of course you can exchange "int" with "double" in my class which gives you a much larger range, but the numbers quickly get inaccurate. If you just need "some level" that's probably fine. However keep in mind when using floating point numbers the higher the number gets, the greater the smallest representable amount will be. So at high numbers you can't add small amounts to that number.

 n2 += n1;      // n2new = n2old + n1old
 n1 = n2 - n1;  // n1new = (n2new - n1old) == (n2old + n1old - n1old) == n2old