Reuse variable as a return value *foo prefix while declaring another one.

[Kelimion]

Is your feature request related to a problem? Please describe.
Sometimes you end up calling an API (several times), but can't use or_return because it's incompatible
with the procedure return type, for example when wrapping platform-specific code.

foo :: proc(a, b: int) -> (res: bool, error: Error) {
	x, x_ok := bar(a, b)
	if !x_ok {
		return false, .Blah
	}

	y, y_ok := baz(a, b)
	if !y_ok {
		return
	}
}

Describe the solution you'd like
It would be nice in cases like these to reuse a variable (from the same scope).

Allowed:

foo :: proc(a, b: int) -> (res: bool, error: Error) {
	x, ok := bar(a, b) // declare and use `x` and `ok`
	if !ok {
		return false, .Blah
	}

	y, *ok := baz(a, b) // declare and use `y`, reuse `ok` from above.
	if ok {
		return
	}
}

Disallowed:

foo :: proc(a, b: int) -> (res: bool, error: Error) {
	x, ok := bar(a, b) // declare and use `x` and `ok`
	if !ok {
		return false, .Blah
	}

	{
		// This should result in an error: "Scope doesn't contain an `ok` variable to reuse."
		// Why? It's bug-prone to declare one variable (y) at the same time as you're reusing one
		// from another scope.

		y, *ok := baz(a, b)
		if ok {
			return
		}
	}
}

Allowed:

foo :: proc(a, b: int) -> (res: bool, error: Error) {
	x, ok := bar(a, b) // declare and use `x` and `ok`
	if !ok {
		return false, .Blah
	}

	{
		y, ok := baz(a, b) // Declares `y`, shadows `ok`.
		if ok {
			return
		}

		z, *ok := baz(a, b) // Declares `z`, reuses `ok` from *this* scope.
		if ok {
			return
		}

	}
}

In all these cases we can't rely on or_return to strip off the second return value, so we end up
with a proliferation of <name>_ok or <name>_err variables.