hashes: remove engine/from_engine from embedded test

This commit illustrates the transformation I intend to make everywhere
we use newtyped hashes as "general hashes". *Within the module that the
newtype is defined* I encapsulate engine calls, which I do by calling
engine methods on the underlying general hash function. So within the
module there is a slight reduction in type safety, in the sense that I
need to make sure that I'm wrapping stuff properly.

But outside of the module, there will be no difference except that I
will no longer export engine/from_engine/hash/etc on newtyped hashes.
Instead callers will need to compute the newtyped hash only in ways
supported by the API.

In theory we could have a macro to produce engine/from_engine/etc for
newtypes that want to act as general hashes. But AFAICT there is no use
case for this.

Alternately, we could have a macro that produces *private* Engine types
and private engine/from_engine/etc methods for the hashes, which could
be used within the module and would provide stronger type safety within
the module. But in practice, raw hashing is usually only used within a
couple of methods, so all this infrastructure is way overkill and will
just make maintenance harder for everybody.

hashes/embedded/src/main.rs

@@ -33,11 +33,11 @@ fn main() -> ! {
     #[cfg(feature = "alloc")]
     unsafe { ALLOCATOR.init(cortex_m_rt::heap_start() as usize, HEAP_SIZE) }
 
-    let mut engine = TestType::engine();
+    let mut engine = sha256::Hash::engine();
     engine.write_all(b"abc").unwrap();
     check_result(engine);
 
-    let mut engine = TestType::engine();
+    let mut engine = sha256::Hash::engine();
     engine.input(b"abc");
     check_result(engine);
 
@@ -46,7 +46,7 @@ fn main() -> ! {
 }
 
 fn check_result(engine: sha256::HashEngine) {
-    let hash = TestType::from_engine(engine);
+    let hash = TestType(sha256::Hash::from_engine(engine));
 
     let hash_check =
         TestType::from_str("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad")