Fix executeFromVar/executeFromReg

[SethDusek]

executeFromVar and executeFromReg execute Exprs from context vars/registers. This is implemented by replacing instances of DeserializeContext/DeserializeRegister nodes with exprs during deserialization. In sigma-rust however this is done during evaluation:

sigma-rust/ergotree-interpreter/src/eval/deserialize_context.rs

Lines 13 to 42 in e56e6fa

	impl Evaluable for DeserializeContext {
	fn eval<'ctx>(
	&self,
	env: &mut Env<'ctx>,
	ctx: &Context<'ctx>,
	) -> Result<Value<'ctx>, EvalError> {
	match ctx.extension.values.get(&self.id) {
	Some(c) => {
	let expected_tpe = SType::SColl(SType::SByte.into());
	if c.tpe != expected_tpe {
	Err(EvalError::UnexpectedExpr(format!(
	"DeserializeContext: expected extension value {} with id {} to have type {:?} got {:?}",
	c, self.id, expected_tpe, c.tpe
	)))
	} else {
	let bytes = c.v.clone().try_extract_into::<Vec<u8>>()?;
	let expr = Expr::sigma_parse_bytes(bytes.as_slice())?;
	if expr.tpe() != self.tpe {
	return Err(EvalError::UnexpectedExpr(format!("DeserializeContext: expected deserialized expr from extension value {} with id {} to have type {:?}, got {:?}", c, self.id, self.tpe, expr.tpe())));
	}
	expr.eval(env, ctx)
	}
	}
	None => Err(EvalError::NotFound(format!(
	"DeserializeContext: no value with id {} in context extension map {}",
	self.id, ctx.extension
	))),
	}
	}
	}

Which makes recursion (and stack overflows) possible:

    #[test]
    fn eval_recursive() {
        let expr: Expr = DeserializeContext {
            tpe: SType::SBoolean,
            id: 1,
        }
        .into();
        let ctx_ext = ContextExtension {
            values: [(1u8, expr.sigma_serialize_bytes().unwrap().into())]
                .iter()
                .cloned()
                .collect(),
        };
        assert!(try_eval_out_wo_ctx::<bool>(&expr, &ctx).unwrap());
    }

ExecuteFromVar's implementation should instead match sigmastate-interpreters, Reference. DeserializeContext and DeserializeRegister should also not implement Evaluable