Improve generics usability for `Array<T>`

I encountered difficulty when writing generic functions using `Array` e.g.
```rust
fn test_basic_op(a: &af::Array)
where
// T: af::Fromf64 + af::HasAfEnum + ???
{
println!("Element-wise arithmetic");
let b = af::add(&af::sin(a), &T::fromf64(1.5f64), false);

let b2 = af::add(&af::sin(a), &af::cos(a), false);

let b3 = !a;
af::af_print!("sin(a) + 1.5 => ", b);
af::af_print!("sin(a) + cos(a) => ", b2);
af::af_print!("!a => ", b3);

let a_plus_b = a.clone() + b.clone();
af::af_print!("a + b", a_plus_b);

let minus_a = -(a.clone());
af::af_print!("-a ", minus_a);
}
```

After long fight with compile error, I found that
```rust
fn test_basic_op(a: &af::Array)
where
T: af::HasAfEnum
+ af::Fromf64
+ af::Convertable
+ af::ImplicitPromote,
af::Array: std::ops::Neg>,
{
...
}
```
compiles and it's OK.

However, I feel that:
- `Convertable` and `ImplicitPromote` seems implementation detail and I don't want to write them every time when using `Array`.
- `T` should be `Convertable` automatically when `T: HasAfEnum` (i.e. `T` is supported in `arrayfire`).

So I want:
1. Alias-like trait (e.g. `AfScalar: HasAfEnum + ...`) which enables us ignoring implementation detail when using `Array` in generic code
1. Generic trait implementation (e.g. `Convertable`), not implementation for `f32`, `f64` and other types individually

What are your thoughts?