Should we have a keyword to specify self is mutable in function signatures

Current Issue

Ideally we want in functions to be able to define whether self is mutable or not. Currently, the default is that it is mutable, and if we want self to be final then we have to add fin. E.g:

def f(fin self, a, b ....)

However, by default users will most likely always have self be mutable (by not appending fin). This is fine, until we have a final variable and try to access its methods. Then, the compiler will constantly throw errors because self will most likely be mutable (even when it needn't be). Instead, we want that self is final by default and only mutable if the user explicitly defines this. This falls along the line of the philosophy of "strict, but as familiar as possible to those coming from Python. So then we would have the following:

class MyClass
    def c: Int := 10

    def f(self, a) -> Int =>
        a + b

    def g(mut self, a) -> Int =>
        self.c += a
        a + b

def my_class := MyClass()

my_class.f(10)
my_class.g(10)

def fin my_class := MyClass()
my_class.g(10) # gives error!

A few issues here is that:

We introduce yet another keyword.
The keyword fin and mut are relatively similar and might be weird to use them both. The main reasoning is that:
- fin is used in contexts where mutability is generally the default
- mut is used in contexts where non-mutability is generally the default However, this may be seen as too much hand-holding. The issue, as I see it, is that in my experience mutability in modern "strict" languages is the exception, and not the other way around.

High-level description of the feature

Re-add mutable keyword mut, which may only be used in function signatures.

Description of potential implementation

Add to token to parse stage.
Change behavior of check slightly to deal with new token.

JSAbrahams / mamba