Q:

Does dereference equal to a function call?

What happens if I borrow a dereferenced pointer?
let a = some object;
let b = &a;
let c = &*b;

What object has c borrowed? Does the dereferencing op create a temporary object like a function's return value? How does it obey the borrowing rules.
I'm also confused about Box's mutable semantic.
let mut a = Box::new(8us)
*a = 1;

This code works just fine without something like Box::new_mut(). But
let mut a = &8us;
*a = 1;

An error occurs.

A:

Quick answer: It depends.
Long answer: keep reading...

What happens if I borrow a dereferenced pointer?
  If you check out the LLVM-IR that rust generates, you can see everything in fine detail:

let a = 8us;
let b = &a;
let c = &*b;

gets expanded to
let a;
// %a = alloca i64
let b;
// %b = alloca i64*
let c;
// %c = alloca i64*
a = 8us;
// store i64 8, i64* %a
b = &a;
// store i64* %a, i64** %b
let tmp = *b;
// %0 = load i64** %b
c = tmp;
// store i64* %0, i64** %c

now, llvm can easily optimize this stuff out. It gets more complicated once you implement traits like Deref on your own types. Then obviously a function call is involved, but most likely optimized out again, since you shouldn't be doing complicated stuff in the deref function.

What object has c borrowed?

c borrows a

Does the dereferencing op create a temporary object like a function's return value?

Nope, see above

How does it obey the borrowing rules.

*b behaves as if it were a. If you take a reference to it you get a reference to a.

To answer your second issue: 
A Box owns the object it points to. Since you declared your Box to be mutable, you can take eithe a mutable reference or any number of non-mutable references to your object. This means when you dereference the Box rust decides, depending the situation, whether to automatically create a mutable box. In the case of the assignment, your deref'd box is on the left side of the assignment operator, therefor rust tries to get a mutable reference to the object.
If you give your variables types, this becomes more obvious:
let mut x = Box::new(8us);
{
    let y : &usize = &*x;
}
{
    let y : &mut usize = &mut *x;
    *x = 99; // cannot assign to `*x` because it is borrowed
}

