Add ability to deserialize enums from SeqAccessDeserializer

[Mingun]

Motivation of this PR is following: when I rebase #1922 I noticed, that test, introduced in the first commit of #2303 failed after the change. That failure appeared after changing

// seq: A where A: SeqAccess
let rest = SeqAccessDeserializer::new(seq);
let content = try!(Content::deserialize(rest));
let deserializer = ContentDeserializer::<A::Error>::new(content);
// use `deserializer`

to

// seq: A where A: SeqAccess
let deserializer = SeqAccessDeserializer::new(seq);
// use `deserializer`

i. e. after removing intermediate bufferisation step. Because code for the MapAccessDeserializer is the same and it does not suffer from such problem, I checked the difference and realized, that MapAccessDeserializer has a special handling fo the Deserializer::deserialize_enum hint:

serde/serde/src/de/value.rs

Lines 1474 to 1484 in 25381be

	fn deserialize_enum<V>(
	self,
	_name: &str,
	_variants: &'static [&'static str],
	visitor: V,
	) -> Result<V::Value, Self::Error>
	where
	V: de::Visitor<'de>,
	{
	visitor.visit_enum(self)
	}

which is missing for the SeqAccessDeserializer.

Because SeqAccessDeserializer is used in such context when deserialize_enum could be requested from it, I think, it should provide the special implementation for that.

This implementation is following: enum is represented as:

• two elements, where the first element is a tag and the second is a content
• one element: a special case for unit variants, where the second element for content can be missed

Additionally, this PR:

• extends testcases to cover all possible enum variants (Unit, Newtype, Tuple and Struct)
• extends testcases to cover negative scenarios (wrong tag, empty map / seq, missing content for seq)
• changes the error message for the empty map for MapAccessDeserializer from invalid type: map, expected enum to invalid length: 0, expected enum, because actually map is expected, but it should not be empty
• document behavior of Deserializer::deserialize_enum for MapAccessDeserializer and SeqAccessDeserializer

[dtolnay]

Thanks for the PR!

I am not convinced that this is the behavior that would be expected by users. As far as I can tell the motivation explained in the PR description is to make the following:

let deserializer = SeqAccessDeserializer::new(seq);

behave more like the following:

let rest = SeqAccessDeserializer::new(seq);
let content = try!(Content::deserialize(rest));
let deserializer = ContentDeserializer::<A::Error>::new(content);

But I tried that code, and ContentDeserializer also does not deserialize enums from sequences. The current SeqAccessDeserializer is already consistent with this.

use serde::de::value::SeqAccessDeserializer;
use serde::de::{Deserialize, Deserializer, SeqAccess, Visitor};
use serde_derive::Deserialize;
use std::fmt;

#[derive(Deserialize, Debug)]
enum Enum {
    Variant(usize),
}

struct MyVisitor;

impl<'de> Visitor<'de> for MyVisitor {
    type Value = Enum;
    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("repro")
    }
    fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
    where
        A: SeqAccess<'de>,
    {
        let rest = SeqAccessDeserializer::new(seq);
        let content = serde::__private::de::Content::deserialize(rest).unwrap();
        let deserializer = serde::__private::de::ContentDeserializer::<A::Error>::new(content);
        Enum::deserialize(deserializer)
    }
}

fn main() {
    let mut de = serde_json::Deserializer::from_str(r#" ["Variant", 1] "#);
    let e = de.deserialize_any(MyVisitor).unwrap();
    println!("{:?}", e);
}

I'm left unclear about what the motivation for this PR is.