shouldn’t Rust enforce returning from function

How do you enforce returning from exit or a function with a loop that never terminates?

shouldn’t Rust enforce returning from function

This is impossible. How would you enforce that? What prevents a function from panicking, aborting the whole process or just going into an infinite loop? All these things correspond to the never type.

I think you're misunderstanding what the never type is. It's not equivalent to None at all. It's a type that doesn't have any values. This is useful in situations with generic code where for example an error type can be chosen as the never type. Then you could destructure or unwrap a Result without handling the error, cause the type system guarantees the error never occurs.

I think you should read up on the never type a bit more. It's a perfectly natural part of the type system. In fact you can make your own very easily: enum Never {}

I don't know where None comes from (what's the T in Option<T>?)

Assuming you meant (), that's a unit type with one valid value. It's a ZST, but can be created and returned.

! is a bottom type. It's uninhabited. Can't be created. Functions can never return it because they can never construct it. So why's this useful? It can be coerced to any type.

Because the set of valid values for ! is the null set, by contradiction, there do not exist any values valid for the type ! that are invalid for any other type T. Therefore, all valid values of ! are also valid values of any other type T, and you can always convert from it to any other type.

Notably, this is already possible, but language support for it isn't amazing:

enum A {}

fn bar(a: A) {
    let foo: Box<Arc<Rc<Mutex<String>>>> = match a {}
}

Heck you can even do this today:

// `loop {}` never returns, so its type is `!`:
let blah: String = loop {};

It's because they wanted to hack control flow functionality into expressions. Returning None is actually returning something, but never is just a placeholder for any type when they want to do things that may exit the expression entirely. This is an example in the docs

let num: u32 = match get_a_number() {
    Some(num) => num,
    None => break,
};

Break exits the expression without ever producing a value.

This is an unfortunate wart to appease a desire to those that want to be able to write code like they do in legacy languages. There should have been better ways to do this without being a hack IMO