DIP1000 and immutable

[jmh530]

What is the motivation for DIP1000 also applying to immutable?

For instance, in the code (compiled with -dip1000), adapted from 
the spec [1], you get the same errors with immutable function 
parameters as you would with mutable ones. However, should it 
ever matter if you escape an immutable?

```d
@safe:

void thorin(scope immutable(int)*) {}
void gloin(immutable(int)*) {}

immutable(int)* balin(scope immutable(int)* q)
{
     thorin(q);
     gloin(q); // error, gloin() escapes q
     return q; // error, cannot return 'scope' q
}

void main() {
     immutable(int) x = 2;
     immutable(int)* ptrx = &x;
     immutable(int)* ptrz = balin(ptrx);
}
```

I tried basically the same thing in Rust and it doesn't generate 
errors (their borrow checker should be assuming scope by default).

```rust
#![allow(unused_variables)]

fn gloin(x: &i32) {
}

fn ballin(x: &i32) -> &i32 {
     gloin(x);
     return x;
}

fn main() {
     let x = 2;
     let ptrx = &x;
     let ptrz = ballin(ptrx);
}
```

[1] https://dlang.org/spec/function.html#scope-parameters